hipbot 0.2.0 → 1.0.0.rc1

data/lib/hipbot/plugin.rb

@@ -1,11 +1,30 @@
 module Hipbot
-  class Plugin < Reactable
-    attr_accessor :bot
+  module Plugin
+    extend ActiveSupport::Concern
 
-    private
+    included do
+      extend Reactable
+      extend ClassMethods
 
-    def reaction_target
-      bot
+      include Singleton
+      include Helpers
+
+      attr_accessor :response
+
+      delegate :sender, :recipients, :body, :room, :to => :response
+      delegate :bot, :to => Hipbot
+
+      Hipbot.plugins.prepend(self.instance)
+    end
+
+    module ClassMethods
+      def configure
+        yield instance
+      end
+
+      def with_response response
+        instance.tap{ |i| i.response = response }
+      end
     end
   end
 end

data/lib/hipbot/reactable.rb

@@ -1,60 +1,45 @@
 module Hipbot
-  class Reactable
-    def on *regexps, &block
-      @defined_reactions ||= []
-      @defined_reactions << to_reaction(regexps, block)
-    end
-
-    def defined_reactions
-      @defined_reactions ||= []
-      @defined_reactions + class_reactions
+  module Reactable
+    def default *params, &block
+      scope *params do
+        default_reactions << to_reaction(block)
+      end
     end
 
     def default_reactions
-      @default_reactions ||= begin
-        if reaction = self.class.default_reaction
-          [ to_reaction(reaction[0], reaction[-1]) ]
-        else
-          []
-        end
-      end
+      @default_reactions ||= []
     end
 
-    class << self
-      def on *regexps, &block
-        @reactions ||= []
-        @reactions << [regexps, block]
-      end
-
-      def reactions
-        @reactions || []
-      end
-
-      def default &block
-        @default_reaction = [[/(.*)/], block]
-      end
+    def desc text = nil
+      @description.tap{ @description = text }
+    end
 
-      def default_reaction
-        @default_reaction
+    def on *params, &block
+      scope *params do
+        reactions << to_reaction(block)
       end
     end
 
-    private
+    def reactions
+      @reactions ||= []
+    end
 
-    def class_reactions
-      @class_reactions ||= self.class.reactions.map do |opts|
-        to_reaction(opts[0], opts[-1])
-      end
+    def scope *params, &block
+      options = params.last.kind_of?(Hash) ? params.pop : {}
+      options_stack << options.merge({ regexps: params, desc: desc })
+      yield
+      options_stack.pop
     end
 
-    def to_reaction(regexps, block)
-      regexps = regexps.dup
-      options = regexps[-1].kind_of?(Hash) ? regexps.pop : {}
-      Reaction.new(reaction_target, regexps, options, block)
+    protected
+
+    def to_reaction block
+      current_options = options_stack.inject{ |all, h| all.merge(h) }
+      Reaction.new(self, current_options, block)
     end
 
-    def reaction_target
-      self
+    def options_stack
+      @options_stack ||= []
     end
   end
 end

data/lib/hipbot/reaction.rb

@@ -1,66 +1,65 @@
 module Hipbot
-  class Reaction < Struct.new(:bot, :regexps, :options, :block)
-
-    def invoke sender, room, message
-      message   = message_for(message, sender)
-      arguments = arguments_for(message)
-      Response.new(bot, self, room, message).invoke(arguments)
+  class Reaction < Struct.new(:plugin, :options, :block)
+    def any_room?
+      options[:room] == true
     end
 
-    def match? sender, room, message
-      message = message_for(message, sender)
-      matches_regexp?(message) && matches_scope?(room, message) && matches_sender?(message) && matches_room?(room)
+    def anything?
+      regexps.blank?
     end
 
-    def inspect
-      "#<Hipbot::Reaction #{regexps} #{options}>"
+    def anywhere?
+      options[:room].nil?
     end
 
-    protected
-
-    def message_for message, sender
-      Message.new(message, sender)
+    def desc
+      options[:desc]
     end
 
-    def arguments_for message
-      (global? ? message.raw_body : message.body).match(matching_regexp(message))[1..-1]
+    def from_all?
+      options[:from].blank?
     end
 
-    def matches_regexp?(message)
-      matching_regexp(message).present?
+    def global?
+      !!options[:global]
     end
 
-    def matching_regexp(message)
-      regexps.find{ |regexp| regexp =~ (global? ? message.raw_body : message.body) }
+    def inspect
+      "#<Hipbot::Reaction #{options}>"
     end
 
-    def matches_scope?(room, message)
-      global? || message.for?(bot) || room.nil?
+    def plugin_name
+      plugin.name.demodulize
     end
 
-    def matches_room?(room)
-      return true if options[:room].nil?
-      room.present? && (rooms.include?(room.name) || options[:room] == true)
+    def match_with message
+      Match.new(self, message)
     end
 
-    def matches_sender?(message)
-      from_all? || users.include?(message.sender.name)
+    def private_message_only?
+      options[:room] == false
     end
 
-    def global?
-      !!options[:global]
+    def readable_command
+      regexps.to_s.gsub(/(?<!\\)(\/|\[|\]|\^|\\z|\$|\\)/, '')
     end
 
-    def from_all?
-      options[:from].blank?
+    def regexps
+      options[:regexps]
     end
 
     def rooms
-      Array(options[:room]).flat_map{ |v| bot.rooms[v].presence || [v] }
+      replace_symbols options[:room], Hipbot.rooms
     end
 
     def users
-      Array(options[:from]).flat_map{ |v| bot.teams[v].presence || [v] }
+      replace_symbols options[:from], Hipbot.teams
+    end
+
+    protected
+
+    def replace_symbols values, replacements_hash
+      Array(values).flat_map{ |v| replacements_hash[v].presence || v.to_s }
     end
   end
 end

data/lib/hipbot/response.rb

@@ -1,29 +1,32 @@
 module Hipbot
-  class Response < Struct.new(:bot, :reaction, :room, :message)
-    delegate :sender, :recipients, :body, :to => :message
+  class Response < Struct.new(:reaction, :message)
     include Helpers
 
-    def initialize bot, reaction, room, message
-      super
-      extend(bot.helpers)
-    end
+    delegate :sender, :recipients, :body, :room, :to => :message
+    delegate :bot, :to => Hipbot
 
     def invoke arguments
+      Hipbot.logger.info("REACTION #{reaction.inspect}")
       instance_exec(*arguments, &reaction.block)
+      true
     rescue Exception => e
       Hipbot.logger.error(e)
-      instance_exec(e, &bot.error_handler)
+      instance_exec(e, &Hipbot.error_handler)
+      false
     end
 
-    private
+    protected
 
     def reply message, room = self.room
-      Hipbot.logger.info("REPLY in #{room}: #{message}")
-      room.nil? ? bot.send_to_user(sender, message) : bot.send_to_room(room, message)
+      room.nil? ? Hipbot.send_to_user(sender, message) : Hipbot.send_to_room(room, message)
+    end
+
+    def method_missing method, *args, &block
+      plugin.send(method, *args, &block)
     end
 
     def plugin
-      bot.plugin_for(reaction)
+      reaction.plugin.with_response(self)
     end
   end
 end

data/lib/hipbot/room.rb

@@ -1,22 +1,15 @@
 module Hipbot
-  class Room < Collection
-    attr_accessor :user_ids
-
-    def initialize *args
-      super
-      self.user_ids = []
-    end
-
+  class Room
     def set_topic topic
-      Bot.instance.set_topic(self, topic)
+      Hipbot.set_topic(self, topic)
     end
 
     def send_message message
-      Bot.instance.send_to_room(self, message)
+      Hipbot.send_to_room(self, message)
     end
 
     def users
-      User.find_many(user_ids)
+      @users ||= []
     end
   end
 end

data/lib/hipbot/user.rb

@@ -1,7 +1,13 @@
 module Hipbot
-  class User < Collection
+  class User
+    include Reactable
+
     def send_message message
-      Bot.instance.send_to_user name, message
+      Hipbot.send_to_user self, message
+    end
+
+    def mention
+      attributes['mention'] || name.delete(' ')
     end
 
     def first_name

data/lib/hipbot/version.rb

@@ -1,3 +1,3 @@
 module Hipbot
-  VERSION = "0.2.0"
+  VERSION = "1.0.0.rc1"
 end

data/spec/integration/hipbot_spec.rb

@@ -1,117 +1,145 @@
 require 'spec_helper'
+require_relative './my_hipbot'
 
-module HipbotHelpers
-  def project_name
-    "#{room.name} project"
-  end
+describe MyHipbot do
+  before(:all) { MyHipbot.instance.setup }
+  subject { MyHipbot.instance }
 
-  def sender_first_name
-    "you are #{message.sender.split[0]}"
-  end
-end
+  let(:room)   { Hipbot::Room.create(id: '1', name: 'Project 1', topic: 'project 1 stuff only') }
+  let(:sender) { Hipbot::User.create(id: '1', name: 'John Doe') }
+  let(:other_room)   { Hipbot::Room.create(id: '2', name: 'Hyde Park', topic: 'nice weather today') }
+  let(:other_sender) { Hipbot::User.create(id: '2', name: 'Other Guy') }
 
-class AwesomePlugin < Hipbot::Plugin
-  on /respond awesome/ do
-    reply("awesome responded")
+  before do
+    Hipbot.bot.configuration.user = Hipbot::User.create(name: 'robbot')
   end
-end
 
-class CoolPlugin < Hipbot::Plugin
-  on /respond cool/ do
-    reply("cool responded")
-  end
-end
+  describe 'configuration' do
+    it 'should set robot name' do
+      subject.name.should == 'robbot'
+    end
 
-class MyHipbot < Hipbot::Bot
-  configure do |config|
-    config.name = 'robbot'
-    config.jid = 'robbot@chat.hipchat.com'
-    config.helpers = HipbotHelpers
-    config.plugins = [ AwesomePlugin, CoolPlugin.new ]
+    it 'should set hipchat token' do
+      subject.jid.should == 'robbot@chat.hipchat.com'
+    end
   end
 
-  on /^hello hipbot!$/ do
-    reply("hello!")
-  end
+  describe 'replying' do
+    it 'should reply to hello' do
+      subject.expects(:send_to_room).with(room, 'hello!')
+      subject.react(sender, room, '@robbot hello hipbot!')
+    end
 
-  on /you're (.*), robot/ do |adj|
-    reply("I know I'm #{adj}")
-  end
+    it 'should reply with argument' do
+      subject.expects(:send_to_room).with(room, "I know I'm cool")
+      subject.react(sender, room, '@robbot you\'re cool, robot')
+    end
 
-  on /hi everyone!/, global: true do
-    reply('hello!')
-  end
+    it 'should reply to global message' do
+      subject.expects(:send_to_room).with(room, 'hello!')
+      subject.react(sender, room, 'hi everyone!')
+    end
 
-  on /tell me the project name/ do
-    reply(project_name)
+    it 'should respond with default reply' do
+      subject.expects(:send_to_room).with(room, "I didn't understand you")
+      subject.react(sender, room, '@robbot blahlblah')
+    end
   end
 
-  on /tell me my name/ do
-    reply("you are #{sender.first_name}")
+  describe '"from" option' do
+    it 'reacts to sender from required team' do
+      subject.expects(:send_to_room).with(room, 'restarting')
+      subject.react(sender, room, '@robbot restart')
+    end
+
+    it 'ignores sender when not in team' do
+      subject.expects(:send_to_room).with(room, 'What do you mean, Other Guy?')
+      subject.react(other_sender, room, '@robbot restart')
+    end
   end
 
-  default do
-    reply("I didn't understand you")
+  describe '"room" option' do
+    it 'reacts in required room' do
+      subject.expects(:send_to_room).with(room, 'deploying')
+      subject.react(sender, room, '@robbot deploy')
+    end
+
+    it 'ignores other rooms' do
+      subject.expects(:send_to_room).with(other_room, "I didn't understand you")
+      subject.react(sender, other_room, '@robbot deploy')
+    end
   end
-end
 
-describe MyHipbot do
-  subject { described_class.instance }
+  describe 'room=true' do
+    it 'reacts in any room' do
+      subject.expects(:send_to_room).with(room, 'doing room thing')
+      subject.react(sender, room, '@robbot room thing')
+    end
 
-  let(:room)   { Hipbot::Room.create('1', 'private', topic: 'topic') }
-  let(:sender) { Hipbot::User.create('1', 'John Doe') }
+    it 'ignores room commands if not in room' do
+      subject.expects(:send_to_user).with(sender, "I didn't understand you")
+      subject.react(sender, nil, 'room thing')
+    end
+  end
 
-  describe "configuration" do
-    it "should set robot name" do
-      subject.name.should == 'robbot'
+  describe 'room=false' do
+    it 'ignores private command in room' do
+      subject.expects(:send_to_room).with(room, "I didn't understand you")
+      subject.react(sender, room, '@robbot private thing')
     end
 
-    it "should set hipchat token" do
-      subject.jid.should == 'robbot@chat.hipchat.com'
+    it 'allows private command if not in room' do
+      subject.expects(:send_to_user).with(sender, 'doing private thing')
+      subject.react(sender, nil, 'private thing')
     end
   end
 
-  describe "replying" do
-    it "should reply to hello" do
-      subject.expects(:send_to_room).with(room, 'hello!')
-      subject.react(sender, room, '@robbot hello hipbot!')
+  describe 'scope' do
+    it 'sets its attributes to every reaction inside' do
+      subject.expects(:send_to_room).with(room, 'doing John Doe thing')
+      subject.react(sender, room, '@robbot John Doe thing')
     end
 
-    it "should reply with argument" do
-      subject.expects(:send_to_room).with(room, "I know I'm cool")
-      subject.react(sender, room, "@robbot you're cool, robot")
+    it 'does not match other senders' do
+      subject.expects(:send_to_room).with(room, 'What do you mean, Other Guy?')
+      subject.react(other_sender, room, '@robbot John Doe thing')
     end
 
-    it "should reply to global message" do
-      subject.expects(:send_to_room).with(room, "hello!")
-      subject.react(sender, room, "hi everyone!")
+    it 'merges params if embedded' do
+      subject.expects(:send_to_room).with(room, 'doing John Doe project thing')
+      subject.react(sender, room, '@robbot John Doe project thing')
     end
 
-    it "should respond with default reply" do
-      subject.expects(:send_to_room).with(room, "I didn't understand you")
-      subject.react(sender, room, "@robbot blahlblah")
+    it 'ignores message from same sander in other room' do
+      subject.expects(:send_to_room).with(other_room, "I didn't understand you")
+      subject.react(sender, other_room, '@robbot John Doe project thing')
+    end
+
+    it 'ignores message from other sender in same room' do
+      subject.expects(:send_to_room).with(room, 'What do you mean, Other Guy?')
+      subject.react(other_sender, room, '@robbot John Doe project thing')
     end
   end
 
-  describe "custom helpers" do
-    it "should have access to room variable" do
-      subject.expects(:send_to_room).with(room, 'private project')
+  describe 'custom helpers' do
+    it 'should have access to room variable' do
+      subject.expects(:send_to_room).with(room, 'Project: Project 1')
       subject.react(sender, room, '@robbot tell me the project name')
     end
 
-    it "should have access to message variable" do
+    it 'should have access to message variable' do
       subject.expects(:send_to_room).with(room, 'you are John')
       subject.react(sender, room, '@robbot tell me my name')
     end
   end
 
-  describe "plugins" do
-    it "should reply to reaction defined in plugin" do
+  describe 'plugins' do
+    it 'should reply to reaction defined in plugin' do
       subject.expects(:send_to_room).with(room, 'awesome responded')
       subject.react(sender, room, '@robbot respond awesome')
     end
 
-    it "should reply to reaction defined in second plugin" do
+    it 'should reply to reaction defined in second plugin' do
       subject.expects(:send_to_room).with(room, 'cool responded')
       subject.react(sender, room, '@robbot respond cool')
     end