scamp 1.2.0 → 2.0.0.pre

data/lib/scamp.rb

@@ -1,31 +1,16 @@
 require 'eventmachine'
-require 'em-http-request'
-require 'yajl'
 require "logger"
 
 require "scamp/version"
-require 'scamp/connection'
-require 'scamp/rooms'
-require 'scamp/users'
 require 'scamp/matcher'
-require 'scamp/action'
-require 'scamp/messages'
+require 'scamp/adapter'
+require 'scamp/plugin'
 
 class Scamp
-  include Connection
-  include Rooms
-  include Users
-  include Messages
+  attr_accessor :adapters, :plugins, :matchers, :logger, :verbose, :first_match_only, :required_format, :strip_prefix
 
-  attr_accessor :rooms, :user_cache, :room_cache, :matchers, :api_key, :subdomain,
-                :logger, :verbose, :first_match_only, :ignore_self, :required_prefix,
-                :rooms_to_join
-
-  def initialize(options = {})
+  def initialize(options = {}, &block)
     options ||= {}
-    raise ArgumentError, "You must pass an API key" unless options[:api_key]
-    raise ArgumentError, "You must pass a subdomain" unless options[:subdomain]
-
     options.each do |k,v|
       s = "#{k}="
       if respond_to?(s)
@@ -34,31 +19,41 @@ class Scamp
         logger.warn "Scamp initialized with #{k.inspect} => #{v.inspect} but NO UNDERSTAND!"
       end
     end
-    
-    @rooms_to_join = []
-    @rooms = {}
-    @user_cache = {}
-    @room_cache = {}
+
+    @strip_prefix ||= true
     @matchers ||= []
+    @adapters ||= {}
+    @plugins  ||= []
+
+    yield self
   end
-  
-  def behaviour &block
-    instance_eval &block
+
+  def adapter name, klass, opts={}
+    adapter = klass.new self, opts
+    sid = adapter.subscribe do |context, msg|
+      process_message(name, context, msg)
+    end
+    @adapters[name] = {:adapter => adapter, :sid => sid}
   end
-  
-  def connect!(room_list, &blk)
-    logger.info "Starting up"
-    connect(api_key, room_list, &blk)
+
+  def plugin klass, opts={}
+    plugins << klass.new(self, opts)
   end
-  
-  def command_list
-    matchers.map{|m| [m.trigger, m.conditions] }
+
+  def connect!
+    EM.run do
+      @adapters.each do |name, data|
+        logger.info "Connecting to #{name} adapter"
+        data[:adapter].connect!
+      end
+    end
   end
 
   def logger
     unless @logger
       @logger = Logger.new(STDOUT)
       @logger.level = (verbose ? Logger::DEBUG : Logger::INFO)
+      @logger.info "Scamp using default logger as none was provided"
     end
     @logger
   end
@@ -73,18 +68,13 @@ class Scamp
     @first_match_only
   end
 
-  private
-
   def match trigger, params={}, &block
-    params ||= {}
-    matchers << Matcher.new(self, {:trigger => trigger, :action => block, :conditions => params[:conditions], :required_prefix => required_prefix})
+    matchers << Matcher.new(self, {:trigger => trigger, :action => block, :on => params[:on], :conditions => params[:conditions]})
   end
-  
-  def process_message(msg)
-    logger.debug "Received message #{msg.inspect}"
-    return false if ignore_self && is_me?(msg[:user_id])
+
+  def process_message(channel, context, msg)
     matchers.each do |matcher|
-      break if first_match_only & matcher.attempt(msg)
+      break if first_match_only & matcher.attempt(channel, context, msg)
     end
   end
 end

data/scamp.gemspec

@@ -5,8 +5,8 @@ require "scamp/version"
 Gem::Specification.new do |s|
   s.name        = "scamp"
   s.version     = Scamp::VERSION
-  s.authors     = ["Will Jessop"]
-  s.email       = ["will@willj.net"]
+  s.authors     = ["Will Jessop", "Adam Holt"]
+  s.email       = ["will@willj.net", "me@adamholt.co.uk"]
   s.homepage    = "https://github.com/wjessop/Scamp"
   s.summary     = %q{Eventmachine based Campfire bot framework}
   s.description = %q{Eventmachine based Campfire bot framework}
@@ -15,13 +15,12 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  
-  s.add_dependency('eventmachine', '~> 1.0.0.rc.4')
-  s.add_dependency('yajl-ruby', '~> 1.1')
-  s.add_dependency('em-http-request', '~> 1.0')
 
-  s.add_development_dependency "rake", "~> 0.9"
-  s.add_development_dependency "rspec", "~> 2.6"
-  s.add_development_dependency "mocha", "~> 0.10"
-  s.add_development_dependency "webmock", "~> 1.7"
+  s.add_dependency 'eventmachine', '~> 1.0'
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", '~> 2.11'
+  s.add_development_dependency "mocha", '~> 0.12'
+  s.add_development_dependency "webmock", '~> 1.8'
+  s.add_development_dependency "simplecov"
 end

data/spec/lib/adapter_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Scamp::Adapter do
+  let(:bot) { stub }
+  describe "#new" do
+    it "creates a new adapter" do
+      adapter = Scamp::Adapter.new(bot)
+      adapter.should_not be_nil
+    end
+
+    it "accepts a hash of options" do
+      adapter = Scamp::Adapter.new(bot, :hello => "world")
+      adapter.should_not be_nil
+    end
+  end
+
+  describe ".matches_required_format?" do
+    let(:adapter) { Scamp::Adapter.new(bot) }
+    let(:bot) { stub(:required_format => nil) }
+
+    describe "no requirement" do
+      it "matches required format" do
+        adapter.matches_required_format?("Hello").should be_true
+      end
+    end
+
+    describe "string requirement" do
+      let(:bot) { stub(:required_format => "Bot: ") }
+
+      it "matches msg with correct prefix" do
+        adapter.matches_required_format?("Bot: Hello").should be_true
+      end
+
+      it "does not match msg with incorrect prefix" do
+        adapter.matches_required_format?("Not: Hello").should be_false
+      end
+    end
+
+    describe "regex requirement" do
+      let(:bot) { stub(:required_format => /^Bot: /) }
+
+      it "matches msg with correct prefix" do
+        adapter.matches_required_format?("Bot: Hello").should be_true
+      end
+
+      it "does not match msg with incorrect prefix" do
+        adapter.matches_required_format?("Not: Hello").should be_false
+      end
+    end
+
+    describe "other requirement" do
+      let(:bot) { stub(:required_format => Object.new) }
+
+      it "raises an ArgumentError" do
+        expect {
+          adapter.matches_required_format?("Bot: Hello").should be_true
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe ".strip_prefix" do
+    describe "with strip_prefix enabled" do
+      describe "with a string require_format" do
+        let(:adapter) { Scamp::Adapter.new(bot) }
+        let(:bot) { stub(:required_format => "Bot: ", :strip_prefix => true) }
+
+        it "should strip the required_format if it is a string" do
+          adapter.strip_prefix("Bot: Hello").should == "Hello"
+        end
+
+        it "should not strip an incorrect prefix" do
+          adapter.strip_prefix("Not: Hello").should == "Not: Hello"
+        end
+      end
+
+      describe "with a Regex require_format" do
+        let(:adapter) { Scamp::Adapter.new(bot) }
+        let(:bot) { stub(:required_format => /^Bot: /, :strip_prefix => true) }
+
+        it "should strip the required_format if it is a string" do
+          adapter.strip_prefix("Bot: Hello").should == "Bot: Hello"
+        end
+
+        it "should not strip an incorrect prefix" do
+          adapter.strip_prefix("Not: Hello").should == "Not: Hello"
+        end
+      end
+    end
+
+    describe "with strip_prefix disabled" do
+      let(:adapter) { Scamp::Adapter.new(bot) }
+      let(:bot) { stub(:required_format => "Bot: ", :strip_prefix => false) }
+
+      it "should strip the required_format if it is a string" do
+        adapter.strip_prefix("Bot: Hello").should == "Bot: Hello"
+      end
+
+      it "should not strip an incorrect prefix" do
+        adapter.strip_prefix("Not: Hello").should == "Not: Hello"
+      end
+    end
+  end
+
+  describe "channels" do
+    let(:adapter) { Scamp::Adapter.new(bot) }
+
+    describe ".push" do
+      it "should push through the correct value" do
+        EM.run_block do
+          value = nil
+          adapter.subscribe do |msg|
+            value = msg
+          end
+          adapter.push "Hello World"
+
+          value.should == "Hello World"
+        end
+      end
+    end
+
+    describe ".subscribe" do
+      it "allows subscriptions" do
+        EM.run_block do
+          subscribed = false
+          adapter.subscribe do |msg|
+            subscribed = true
+          end
+          adapter.push true
+
+          subscribed.should be_true
+        end
+      end
+    end
+  end
+
+  describe ".connect!" do
+    let(:adapter) { Scamp::Adapter.new(bot) }
+    it "should raise an implementation error" do
+      expect {
+        adapter.connect!
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/matcher_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Scamp::Matcher do
+  describe "#new" do
+    let(:bot) { stub(adapters: {one: "two"}) }
+
+    it "requires a trigger" do
+      expect {
+        Scamp::Matcher.new(bot, action: ->(ctx, msg){})
+      }.to raise_error(ArgumentError)
+    end
+
+    it "requires a action" do
+      expect {
+        Scamp::Matcher.new(bot, trigger: "Hello")
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ".attempt" do
+    context "channels" do
+      let(:msg) { Scamp::Message.new stub, body: "hello" }
+
+      context "listened" do
+        it "runs the action when" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true}
+          matcher.attempt(:one, stub, msg)
+          result.should be_true
+        end
+      end
+
+      context "unlistened" do
+        it "does not run the action" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true}
+          matcher.attempt(:two, stub, msg)
+          result.should be_false
+        end
+      end
+    end
+
+    context "triggers" do
+      context "matching" do
+        it "runs the action" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true}
+          msg = Scamp::Message.new stub, body: "hello"
+
+          matcher.attempt(:one, stub, msg)
+          result.should be_true
+        end
+      end
+
+      context "non matching" do
+        it "runs the action" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true}
+          msg = Scamp::Message.new stub, body: "goodbye"
+
+          matcher.attempt(:one, stub, msg)
+          result.should be_false
+        end
+      end
+    end
+
+    context "validations" do
+      let(:message_class) {
+        class MyMessage < Scamp::Message
+          def valid?(conditions)
+            conditions[:hello] == "world"
+          end
+        end
+        MyMessage
+      }
+
+      context "valid message" do
+        it "runs the action" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true},
+                                 conditions: {hello: "world"}
+
+          msg = message_class.new stub, body: "hello"
+
+          matcher.attempt(:one, stub, msg)
+          result.should be_true
+        end
+      end
+
+      context "invalid message" do
+        it "runs the action" do
+          result = false
+          matcher = Scamp::Matcher.new stub,
+                                         on: [:one],
+                                    trigger: "hello",
+                                     action: ->(ctx, msg){result = true},
+                                 conditions: {hello: "goodbye"}
+
+          msg = message_class.new stub, body: "hello"
+
+          matcher.attempt(:one, stub, msg)
+          result.should be_false
+        end
+      end
+    end
+  end
+end

data/spec/lib/matches_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Scamp::Matches do
+  let(:msg) { "Name: Scamp, URL: https://github.com/wjessop/Scamp/" }
+  let(:match) { msg.match(/^Name: (?<name>\w+), URL: (?<url>.*)/) }
+  let(:matches) { Scamp::Matches.new(match) }
+
+  it "exposes the name from the capture" do
+    matches.name.should eql("Scamp")
+    matches[0].should eql("Scamp")
+  end
+
+  it "exposes the url from the capture" do
+    matches.url.should eql("https://github.com/wjessop/Scamp/")
+    matches[1].should eql("https://github.com/wjessop/Scamp/")
+  end
+
+  describe '.each' do
+    it "iterates over each match" do
+      results = []
+      matches.each do |match|
+        results << match
+      end
+
+      results.should include("Scamp")
+      results.should include("https://github.com/wjessop/Scamp/")
+    end
+  end
+end

data/spec/lib/message_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Scamp::Message do
+  describe "#new" do
+    it "should store and provide access to metadata" do
+      msg = Scamp::Message.new("foo", body: "hello", foo: "foo", bar: "bar")
+      msg.foo.should eql("foo")
+      msg.bar.should eql("bar")
+    end
+
+    it "should maintain metadata integrity when multiple instances exist" do
+      msg = Scamp::Message.new("foo", body: "hello", foo: "foo")
+      msg2 = Scamp::Message.new("foo", body: "hello", foo: "ouchie")
+      msg.foo.should eql("foo")
+      msg.foo.should eql("foo")
+    end
+
+    it "should isolate data access message instances created by different adapters" do
+      msg = Scamp::Message.new("foo", body: "hello", foo: "foo")
+      msg2 = Scamp::Message.new("foo2", body: "hello", bar: "bar")
+
+      msg.should respond_to(:foo)
+      msg.should_not respond_to(:bar)
+
+      msg2.should respond_to(:bar)
+      msg2.should_not respond_to(:foo)
+    end
+  end
+
+  describe ".valid?" do
+    it "returns true by default" do
+      msg = Scamp::Message.new('foo', body: "hello")
+      msg.valid?(nil).should be_true
+    end
+  end
+
+  describe ".matches?" do
+    let(:msg) { Scamp::Message.new('foo', body: "hello") }
+
+    it "matches a string trigger" do
+      msg.matches?("hello").should be_true
+    end
+
+    it "matches a regex trigger" do
+      msg.matches?(/^hello$/).should be_true
+    end
+
+    it "does not match an invalid matcher" do
+      msg.matches?("goodbye").should be_false
+    end
+  end
+end

data/spec/lib/plugin_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Scamp::Plugin do
+  describe "#matchers" do
+    it "is empty by default" do
+      Scamp::Plugin.matchers.should be_empty
+    end
+
+    it "should add a new matcher" do
+      expect {
+        Scamp::Plugin.match "Hello", :method
+      }.to change { Scamp::Plugin.matchers.size }.by(1)
+    end
+
+    describe ".new" do
+      let(:bot) { mock }
+      let(:plugin) { 
+        class TestPlugin < Scamp::Plugin
+          match "Hello", :name
+
+          def name(context, msg)
+          end
+        end
+        TestPlugin
+      }
+
+      it "attaches matchers to the bot" do
+        bot.expects(:match).with("Hello", {:on => nil}).once
+        plugin.new(bot)
+      end
+    end
+  end
+end