hipbot 1.0.0.rc2 → 1.0.0

data/lib/hipbot/storages/mongoid.rb

@@ -0,0 +1,18 @@
+module Hipbot
+  module Storages
+    module Mongoid
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Mongoid::Document
+
+        field :_id,  type: String
+        field :name, type: String
+
+        alias_method :to_s, :name
+
+        validate :name, presence: true
+      end
+    end
+  end
+end

data/lib/hipbot/user.rb

@@ -1,7 +1,5 @@
 module Hipbot
   class User
-    include Reactable
-
     def send_message message
       Hipbot.send_to_user self, message
     end
@@ -13,5 +11,13 @@ module Hipbot
     def first_name
       name.split.first
     end
+
+    def myself?
+      self == Hipbot.user
+    end
+
+    def guest?
+      attributes[:role] == 'visitor'
+    end
   end
 end

data/lib/hipbot/version.rb

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

data/spec/integration/my_hipbot.rb

@@ -15,6 +15,26 @@ class AwesomePlugin
   on /respond awesome/ do
     reply('awesome responded')
   end
+
+  def method_reaction param = 'empty'
+    reply("parameter: #{param}")
+  end
+
+  on /^method reaction$/, :method_reaction
+  on /^method reaction (.*)$/, :method_reaction
+  on /^no block reaction$/
+
+  def scope_method_reaction
+    reply('scope method reaction')
+  end
+
+  scope :scope_method_reaction do
+    on /^scope method reaction$/
+  end
+
+  scope /^scope regexp$/ do
+    on :method_reaction
+  end
 end
 
 class CoolPlugin
@@ -24,6 +44,10 @@ class CoolPlugin
   on /respond cool/ do
     reply('cool responded')
   end
+
+  default do
+    reply("I didn't understand you")
+  end
 end
 
 class MyHipbot < Hipbot::Bot
@@ -39,10 +63,6 @@ class MyHipbot < Hipbot::Bot
     reply('What do you mean, Other Guy?')
   end
 
-  default do
-    reply("I didn't understand you")
-  end
-
   desc 'greets the user'
   on /^hello hipbot!$/ do
     reply('hello!')

data/spec/integration/{hipbot_spec.rb → my_hipbot_spec.rb}

@@ -10,13 +10,9 @@ describe MyHipbot do
   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') }
 
-  before do
-    Hipbot.bot.configuration.user = Hipbot::User.create(name: 'robbot')
-  end
-
   describe 'configuration' do
     it 'should set robot name' do
-      subject.name.should == 'robbot'
+      subject.name.should == 'robot'
     end
 
     it 'should set hipchat token' do
@@ -27,12 +23,12 @@ describe MyHipbot do
   describe 'replying' do
     it 'should reply to hello' do
       subject.expects(:send_to_room).with(room, 'hello!')
-      subject.react(sender, room, '@robbot hello hipbot!')
+      subject.react(sender, room, '@robot hello hipbot!')
     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')
+      subject.react(sender, room, '@robot you\'re cool, robot')
     end
 
     it 'should reply to global message' do
@@ -42,38 +38,38 @@ describe MyHipbot do
 
     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')
+      subject.react(sender, room, '@robot blahlblah')
     end
   end
 
   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')
+      subject.react(sender, room, '@robot 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')
+      subject.react(other_sender, room, '@robot restart')
     end
   end
 
   describe '"room" option' do
     it 'reacts in required room' do
       subject.expects(:send_to_room).with(room, 'deploying')
-      subject.react(sender, room, '@robbot deploy')
+      subject.react(sender, room, '@robot 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')
+      subject.react(sender, other_room, '@robot deploy')
     end
   end
 
   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')
+      subject.react(sender, room, '@robot room thing')
     end
 
     it 'ignores room commands if not in room' do
@@ -85,7 +81,7 @@ describe MyHipbot do
   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')
+      subject.react(sender, room, '@robot private thing')
     end
 
     it 'allows private command if not in room' do
@@ -97,51 +93,73 @@ describe MyHipbot do
   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')
+      subject.react(sender, room, '@robot John Doe thing')
     end
 
     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')
+      subject.react(other_sender, room, '@robot John Doe thing')
     end
 
     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')
+      subject.react(sender, room, '@robot John Doe project thing')
     end
 
     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')
+      subject.react(sender, other_room, '@robot 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')
+      subject.react(other_sender, room, '@robot 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, 'Project: Project 1')
-      subject.react(sender, room, '@robbot tell me the project name')
+      subject.react(sender, room, '@robot tell me the project name')
     end
 
     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')
+      subject.react(sender, room, '@robot tell me my name')
     end
   end
 
   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')
+      subject.react(sender, room, '@robot respond awesome')
     end
 
     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')
+      subject.react(sender, room, '@robot respond cool')
+    end
+  end
+
+  describe 'method reaction' do
+    it 'should reply to a method reaction defined in plugin' do
+      subject.expects(:send_to_room).with(room, 'parameter: empty')
+      subject.react(sender, room, '@robot method reaction')
+    end
+
+    it 'should reply to a method reaction defined in plugin with parameters' do
+      subject.expects(:send_to_room).with(room, 'parameter: method param')
+      subject.react(sender, room, '@robot method reaction method param')
+    end
+
+    it 'should reply to a scope method reaction defined in plugin' do
+      subject.expects(:send_to_room).with(room, 'scope method reaction')
+      subject.react(sender, room, '@robot scope method reaction')
+    end
+
+    it 'should reply to a scope regexp with method reaction defined in plugin', focus: true do
+      subject.expects(:send_to_room).with(room, 'parameter: empty')
+      subject.react(sender, room, '@robot scope regexp')
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,20 @@
 require_relative '../lib/hipbot'
 
-require 'coveralls'
-Coveralls.wear!
+# require 'coveralls'
+# Coveralls.wear!
 
 RSpec.configure do |config|
   config.mock_with :mocha
+
+  config.before(:all) do
+    Hipbot::User.send(:include, Hipbot::Storages::Hash)
+    Hipbot::Room.send(:include, Hipbot::Storages::Hash)
+    Hipbot.stubs(logger: NullLogger.instance)
+  end
+end
+
+class NullLogger
+  def self.instance
+    Logger.new('/dev/null')
+  end
 end

data/spec/unit/adapters/hipchat_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Hipbot::Adapters::Hipchat do
+
+end

data/spec/unit/{hipbot_spec.rb → bot_spec.rb}

@@ -5,13 +5,15 @@ describe "a class that inherits", Hipbot::Bot do
 
   before(:each) do
     described_class.instance.plugins.clear
+    described_class.instance.configuration.logger = NullLogger.instance
     described_class.instance.setup
   end
   subject { described_class.instance }
 
+  let(:room) { Hipbot::Room.new(name: 'Test Room') }
+
   context "#on" do
-    let(:sender) { stub_everything(name: 'Tom Smith', reactions: []) }
-    let(:room)   { stub_everything }
+    let(:sender) { Hipbot::User.new(name: 'Tom Smith') }
 
     it "should reply to no arguments" do
       described_class.on /^hello there$/ do
@@ -94,7 +96,7 @@ describe "a class that inherits", Hipbot::Bot do
     end
 
     context "messages from particular sender" do
-      let(:other_user) { stub(name: "John", reactions: []) }
+      let(:other_user) { Hipbot::User.new(name: "John") }
 
       it "should reply" do
         described_class.on /wazzup\?/, from: sender.name do
@@ -105,7 +107,7 @@ describe "a class that inherits", Hipbot::Bot do
       end
 
       it "should reply if sender acceptable" do
-        described_class.on /wazzup\?/, from: [stub, sender.name] do
+        described_class.on /wazzup\?/, from: ['someone', sender.name] do
           reply('wazzup, tom?')
         end
         subject.expects(:send_to_room).with(room, 'wazzup, tom?')
@@ -130,11 +132,10 @@ describe "a class that inherits", Hipbot::Bot do
     end
 
     context "messages in particular room" do
-      let(:room)       { stub(:name => 'room') }
-      let(:other_room) { stub(:name => 'other_room') }
+      let(:other_room) { Hipbot::Room.new(name: 'Test Room 2') }
 
       it "should reply" do
-        described_class.on /wazzup\?/, room: 'room' do
+        described_class.on /wazzup\?/, room: 'Test Room' do
           reply('Wazzup, Tom?')
         end
         subject.expects(:send_to_room).with(room, 'Wazzup, Tom?')
@@ -142,7 +143,7 @@ describe "a class that inherits", Hipbot::Bot do
       end
 
       it "should reply if room acceptable" do
-        described_class.on /wazzup\?/, room: ['other_room', 'room'] do
+        described_class.on /wazzup\?/, room: ['Test Room 2', 'Test Room'] do
           reply('wazzup, tom?')
         end
         subject.expects(:send_to_room).with(room, 'wazzup, tom?')
@@ -150,7 +151,7 @@ describe "a class that inherits", Hipbot::Bot do
       end
 
       it "should not reply if room unacceptable" do
-        described_class.on /wazzup\?/, room: 'room' do
+        described_class.on /wazzup\?/, room: 'Test Room' do
           reply('wazzup, tom?')
         end
         subject.expects(:send_to_room).never
@@ -158,7 +159,7 @@ describe "a class that inherits", Hipbot::Bot do
       end
 
       it "should not reply if room does not match" do
-        described_class.on /wazzup\?/, room: ['other_room'] do
+        described_class.on /wazzup\?/, room: ['Test Room 2'] do
           reply('wazzup, tom?')
         end
         subject.expects(:send_to_room).never
@@ -167,7 +168,7 @@ describe "a class that inherits", Hipbot::Bot do
     end
 
     context "response helper" do
-      let(:user){ stub(name: 'Tom Smith', first_name: 'Tom', reactions: []) }
+      let(:user){ Hipbot::User.new(name: 'Tom Smith') }
 
       it "message" do
         described_class.on /.*/ do
@@ -259,7 +260,7 @@ describe "a class that inherits", Hipbot::Bot do
   end
 
   describe "configurable options" do
-    Hipbot::Bot::CONFIGURABLE_OPTIONS.each do |option|
+    Hipbot::Configuration::OPTIONS.each do |option|
       it "should delegate #{option} to configuration" do
         value = stub
         subject.configuration.expects(option).returns(value)

data/spec/unit/match_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Hipbot::Match do
+  subject { described_class.new(reaction, message) }
+
+  let(:message) { stub(for?: true, body: 'test message') }
+  let(:reaction) do
+    stub(
+      global?: false,
+      from_anywhere?: true,
+      to_anything?: false,
+      from_all?: true,
+      regexps: [/.*/],
+      condition: proc { true }
+    )
+  end
+
+  before do
+    Hipbot.stubs(:user)
+  end
+
+  describe "#matches?" do
+    its(:matches?) { should be_true }
+
+    describe "specific regexp" do
+      describe "matching the message body" do
+        before do
+          message.stubs(body: 'test message')
+          reaction.stubs(regexps: [/\Atest/])
+        end
+
+        its(:matches?) { should be_true }
+      end
+
+      describe "not matching message body" do
+        before do
+          message.stubs(body: 'test message')
+          reaction.stubs(regexps: [/\Arandom/])
+        end
+
+        its(:matches?) { should be_false }
+      end
+    end
+
+    describe "multiple regexps" do
+      describe "matching message body" do
+        before do
+          message.stubs(body: 'test message')
+          reaction.stubs(regexps: [/\Awat/, /\Atest/])
+        end
+
+        its(:matches?) { should be_true }
+      end
+
+      describe "not matching message body" do
+        before do
+          message.stubs(body: 'test message')
+          reaction.stubs(regexps: [/\Awat/, /\Arandom/])
+        end
+
+        its(:matches?) { should be_false }
+      end
+    end
+
+    describe "specific condition" do
+      describe "returning true" do
+        before do
+          reaction.stubs(condition: proc { true })
+        end
+
+        its(:matches?) { should be_true }
+      end
+
+      describe "returning false" do
+        before do
+          reaction.stubs(condition: proc { false })
+        end
+
+        its(:matches?) { should be_false }
+      end
+    end
+  end
+
+  describe "#invoke" do
+    let(:response) { stub }
+
+    before do
+      Hipbot::Response.stubs(new: response)
+    end
+
+    after do
+      subject.invoke
+    end
+
+    describe "a reaction with no regexps" do
+      before do
+        reaction.stubs(to_anything?: true)
+      end
+
+      it "calls response with message body" do
+        response.expects(:invoke).with([message.body])
+      end
+    end
+
+    describe "a reaction with regexp with no variables" do
+      before do
+        reaction.stubs(regexps: [/.*/])
+      end
+
+      it "calls response with message body" do
+        response.expects(:invoke).with([])
+      end
+    end
+
+    describe "a reaction with regexp with one variable" do
+      before do
+        message.stubs(body: 'I like trains.')
+        reaction.stubs(regexps: [/\Ai like (\w+)/i])
+      end
+
+      it "calls response with variable parsed out of message body" do
+        response.expects(:invoke).with(['trains'])
+      end
+    end
+
+    describe "a reaction with regexp with multiple variables" do
+      before do
+        message.stubs(body: 'I like trains and cars.')
+        reaction.stubs(regexps: [/\Ai like (\w+) and (\w+)/i])
+      end
+
+      it "calls response with variables parsed out of message body" do
+        response.expects(:invoke).with(%w{trains cars})
+      end
+    end
+
+    describe "a reaction with multiple regexps with variables" do
+      before do
+        message.stubs(body: 'I enjoy trains and cars.')
+        reaction.stubs(regexps: [/\AI enjoy (\w+) and (\w+)/, /\Ai like (\w+) and (\w+)/i])
+      end
+
+      it "calls response with variable parsed out of message body" do
+        response.expects(:invoke).with(%w{trains cars})
+      end
+    end
+  end
+end