message_router 0.0.2 → 0.1.1

data/lib/message_router/version.rb

@@ -1,3 +1,3 @@
 class MessageRouter
-  VERSION = "0.0.2"
-end
+  VERSION = "0.1.1"
+end

data/message_router.gemspec

@@ -5,8 +5,8 @@ require "message_router/version"
 Gem::Specification.new do |s|
   s.name        = "message_router"
   s.version     = MessageRouter::VERSION
-  s.authors     = ["Brad Gessler"]
-  s.email       = ["brad@bradgessler.com"]
+  s.authors     = ["Brad Gessler", "Paul Cortens"]
+  s.email       = ["brad@bradgessler.com", "paul@thoughtless.ca"]
   s.homepage    = ""
   s.summary     = %q{Route messages}
   s.description = %q{a DSL for routing SMS, Twitter, and other short message formats.}
@@ -17,4 +17,4 @@ 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"]
-end
+end

data/spec/message_router_spec.rb

@@ -1,155 +1,464 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe MessageRouter::Matcher do
-  context "regexp expressions" do
-    it "should return captures" do
-      match = MessageRouter::Matcher.new({:body => /(\w+) (\w+) (\w+)/}).match({:body => 'hi there dude'})
-      match[:body].should eql(%w(hi there dude))
-    end
-  end
-  
-  context "string expressions" do
-    it "should return capture" do
-      match = MessageRouter::Matcher.new({:body => 'testing'}).match({:body => 'testing'})
-      match[:body].should eql(['testing'])
-    end
-  end
-  
-  it "should return captures if all matchers have captures" do
-    match = MessageRouter::Matcher.new({:body => 'testing', :carrier => 'att'}).match({:body => 'testing', :carrier => 'att'})
-    match.should_not be_nil
-  end
-  
-  it "should not return captures if some matchers have captures" do
-    match = MessageRouter::Matcher.new({:body => 'testing', :carrier => 'att'}).match({:body => 'testing', :carrier => 'verizon'})
-    match.should be_nil
-  end
-  
-  it "should not return captures of params are missing" do
-    match = MessageRouter::Matcher.new({:body => 'testing', :carrier => 'att'}).match({:body => 'testing'})
-  end
-  
-  it "should default matcher param to :body" do
-    MessageRouter::Matcher.default_key.should eql(:body)
-  end
-end
+# TODO: Maybe move this into a sub-directory
+describe MessageRouter::Router do
 
-describe MessageRouter do
-  class CrazyTimesRouter < MessageRouter
-    match /^crazy$/ do
-      halt "factory blow out sales are awesome"
-    end
-  end
+  describe ".build" do
+
+    describe 'defining matchers' do
+      describe '1st argument' do
+        before do
+          # For use in confirming whether or not a proc was called.
+          $thing_to_match = $did_it_run = nil
+        end
+
+        let :env do
+          {
+            'body' => 'hello world',
+            'from' => '15554443333',
+            'to'   => '12345'
+          }
+        end
+
+        # This needs to be a method (and not memoized by #let) so that
+        # $thing_to_match can change within a test.
+        def router
+          Class.new MessageRouter::Router do
+            match($thing_to_match) { $did_it_run = true }
+
+            # Using these methods also proves that the message is optionally
+            # passed to helper methods.
+            def always_true
+              env['body'] == 'hello world'
+            end
+            def always_false
+              false
+            end
+          end.new
+        end
+
+        let :the_test do
+          Proc.new do |opts|
+            $thing_to_match = opts[:true]
+            router.call(env)
+            $did_it_run.should == true
+            $did_it_run = nil # reset for next time
+
+            $thing_to_match = opts[:false]
+            router.call(env)
+            $did_it_run.should == nil
+            $did_it_run = nil # reset for next time
+          end
+        end
+
+        it 'accepts a boolean' do
+          the_test.call :true => true, :false => false
+        end
+
+        it 'accepts a nil' do
+          # True is just here as a placeholder
+          the_test.call :true => true, :false => nil
+        end
+
+        it 'accepts a proc which is passed the env' do
+          the_test.call(
+            :true  => Proc.new { env['to'] == '12345'},
+            :false => Proc.new { env['to'] == '54321'}
+          )
+        end
+
+        it 'accepts a regex to match against the message body' do
+          the_test.call :true => /hello/, :false => /bye bye/
+        end
+
+        it 'accepts a string to match against the 1st word in the message body' do
+          the_test.call :true => 'hello', :false => 'hell'
+        end
+
+        it 'accepts a symbol which is a method name' do
+          the_test.call :true => :always_true, :false => :always_false
+        end
 
-  # Test case router
-  class TwitterRouter < MessageRouter
-    context :all_caps_with_numbers do |funny_word, high_def_resolution|
-      match /FUNNYWORD/i do
-        halt "#{funny_word}-#{high_def_resolution}"
+        it 'accepts an Array' do
+          the_test.call :true => %w(only one of these needs to be the word hello), :false => %w(none of these match)
+        end
+
+        describe 'matching an Array' do
+          it "doesn't run the 'do_this' block multiple times if there are multiple matches" do
+            $run_count = 0
+            router = Class.new(MessageRouter::Router) do
+              match [true, true] do
+                $run_count += 1
+                nil # Return nil to ensure this matcher failed.
+              end
+            end.new
+
+            router.call({})
+            $run_count.should == 1
+          end
+
+          it "returns nil if the 'do_this' block returns nil" do
+            $run_count = 0
+            router = Class.new(MessageRouter::Router) do
+              match [true, true] do
+                $run_count += 1
+                nil # Return nil to ensure this matcher failed.
+              end
+            end.new
+
+            router.call({}).should == nil
+          end
+
+        end
+
+        describe 'matching a hash' do
+          it 'accepts a string to match against the hash key' do
+            the_test.call(
+              :true => {
+                'from' => '15554443333',
+                'to'   => '12345'
+              },
+              :false => {
+                'from' => 'something-else',
+                'to'   => '12345'
+              }
+            )
+          end
+          it 'accepts a regex to match against the hash key' do
+            the_test.call(
+              :true => {
+                'from' => /\A1555\d{7}\Z/,
+                'to'   => /\A\d{5}\Z/
+              },
+              :false => {
+                'from' => /\A1555\d{7}\Z/,
+                'to'   => /i don't match/
+              }
+            )
+          end
+          it 'accepts an Array to match against the hash key' do
+            the_test.call(
+              :true => {
+                'from' => [/i don't match/, 'neither do i', 'but this last one does', /\A1555\d{7}\Z/],
+                'to'   => [/i don't match/, 'neither do i', 'but this last one does', /\A\d{5}\Z/]
+              },
+              :false => {
+                'from' => [/\A1555\d{7}\Z/, 'that last one did not match'],
+                'to'   => [/i don't match/, 'neither do i']
+              }
+            )
+          end
+
+          it 'accepts keys that are missing (but is always false)' do
+            $thing_to_match = {'i dont exist' => /.*/}
+            router.call(env)
+            $did_it_run.should == nil
+            $did_it_run = nil # reset for next time
+          end
+        end
       end
 
-      # All caps without numbers... but in a proc
-      context Proc.new{|r| r.message[:body] =~ /^[A-Z\s]+$/ } do
-        match /.+/ do
-          halt "STOP SHOUTING WITHOUT NUMBERS!"
+      describe '2nd argument' do
+        it 'accepts a Proc' do
+          env = {}
+          router = Class.new MessageRouter::Router do
+            match(true, Proc.new { env['did_it_run'] = true })
+          end.new
+          router.call env
+          env['did_it_run'].should be_true
+        end
+
+        it 'accepts a block' do
+          env = {}
+          router = Class.new MessageRouter::Router do
+            match(true) { env['did_it_run'] = true }
+          end.new
+          router.call env
+          env['did_it_run'].should be_true
+        end
+
+        it 'raises an execption when both a Proc and a block are given' do
+          lambda {
+            router = Class.new MessageRouter::Router do
+              match(true, Proc.new { env['did_it_run'] = true }) { env['did_it_run'] = true }
+            end.new
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'raises an execption when neither a Proc nor a block are given' do
+          lambda {
+            router = Class.new MessageRouter::Router do
+              match true
+            end.new
+          }.should raise_error(ArgumentError)
         end
       end
 
-      match /.+/ do
-        halt "STOP SHOUTING WITH NUMBERS!"
+      it 'defaults the 1st argument to true if only a block is given' do
+        env = {}
+        router = Class.new MessageRouter::Router do
+          match { env['did_it_run'] = true }
+        end.new
+        router.call env
+        env['did_it_run'].should be_true
       end
-    end
 
-    mount CrazyTimesRouter
+      it 'defaults the 1st argument to true if only a Proc is given' do
+        env = {}
+        router = Class.new MessageRouter::Router do
+          match(Proc.new { env['did_it_run'] = true })
+        end.new
+        router.call env
+        env['did_it_run'].should be_true
+      end
 
-    match /hi dude/ do
-      halt "pleased to meet you"
-    end
+      it 'accepts a Hash with a symbol as its only key and a Proc as its only value' do
+        env = {}
+        router = Class.new MessageRouter::Router do
+          match :true_method => (Proc.new { env['did_it_run'] = true })
+          def true_method; true; end
+        end.new
+        router.call env
+        env['did_it_run'].should be_true
+      end
 
-    match /hi halt (\w+)/ do |word|
-      halt word
+      it 'raises an execption when no arguments and no block is given' do
+        lambda {
+          router = Class.new MessageRouter::Router do
+            match
+          end.new
+        }.should raise_error(ArgumentError)
+      end
     end
+  end
 
-    match /hi halt/ do
-      halt
+
+  describe "#call" do
+    it "returns nil with no rules" do
+      r = MessageRouter::Router.new
+      r.call({}).should be_nil
     end
-    
-    match /hi (\w+)/ do |name|
-      halt "how do you do #{name}"
+
+    context 'a rule matches' do
+      subject do
+        Class.new MessageRouter::Router do
+          match(true) { env[:did_it_run] = true }
+        end.new
+      end
+
+      it "returns true" do
+        subject.call({}).should be_true
+      end
+
+      it "calls the matcher's code" do
+        subject.call(env = {})
+        env[:did_it_run].should be_true
+      end
     end
-    
-    match /hola (\w+) (\w+)/, :from => 'bradgessler' do |first_name, last_name|
-      halt "hello #{first_name} #{last_name} in spanish"
+
+    context 'there is a prerequisite which is true' do
+      subject do
+        Class.new MessageRouter::Router do
+          prerequisite :true_method
+          match(true) { env[:did_it_run] = true }
+          def true_method; true; end
+        end.new
+      end
+
+      it "returns true" do
+        subject.call({}).should be_true
+      end
+
+      it "calls the matcher's code" do
+        subject.call(env = {})
+        env[:did_it_run].should be_true
+      end
     end
-    
-  private
-    def all_caps_with_numbers
-      if message[:body] =~ /^[A-Z0-9\s]+$/
-        ["Zeldzamar", 1080]
+
+    context 'there is a prerequisite which is false' do
+      subject do
+        Class.new MessageRouter::Router do
+          prerequisite :false_method
+          match(true) { env[:did_it_run] = true }
+          def false_method; false; end
+        end.new
+      end
+
+      it "returns false" do
+        subject.call({}).should be_false
+      end
+
+      it "doesn't calls the matcher's code" do
+        subject.call(env = {})
+        env[:did_it_run].should_not be_true
       end
     end
-  end
 
-  def dispatch(*args)
-    reply = TwitterRouter.dispatch(*args)
-    reply ? reply[:body] : nil
-  end
+    describe 'nested routers' do
+      def main_router
+        Class.new(MessageRouter::Router) do
+          sub_router = Class.new(MessageRouter::Router) do
+            match($inner_matcher) { $did_inner_run = true }
+          end.new
 
-  it "should return nil if there are no matches" do
-    dispatch("bums").should be_nil
-  end
+          match $outer_matcher do
+            $did_outer_run = true
+            sub_router.call(env)
+          end
+        end.new
+      end
 
-  it "should have default key" do
-    TwitterRouter.new.default_key.should eql(:body)
-  end
+      before do
+        $outer_matcher = $inner_matcher = $did_outer_run = $did_inner_run = nil
+      end
 
-  context "mounted router" do
-    it "should process message" do
-      dispatch("crazy").should eql("factory blow out sales are awesome")
-    end
-  end
+      it 'runs both when both match' do
+        $outer_matcher = $inner_matcher = true
 
-  context "should halt" do
-    it "without value" do
-      dispatch("hi halt").should be_nil
-    end
+        main_router.call({}).should be_true
+        $did_outer_run.should be_true
+        $did_inner_run.should be_true
+      end
 
-    it "with value" do
-      dispatch("hi halt narf").should eql("narf")
-    end
-  end
-  
-  context "default matcher" do
-    it "should capture regexps" do
-      dispatch('hi dude').should eql('pleased to meet you')
-    end
-    
-    it "should pass regexp captures through blocks" do
-      dispatch('hi brad').should eql("how do you do brad")
-    end
-  end
-  
-  context "hash matcher" do
-    it "should capture with default matcher" do
-      dispatch('hola jeannette gessler', :from => 'bradgessler').should eql("hello jeannette gessler in spanish")
-    end
+      it "runs outer only when outer matches and inner doesn't" do
+        $outer_matcher = true
+        $inner_matcher = false
 
-    it "should capture with an explicit hash" do
-      dispatch(:body => 'hola jeannette gessler', :from => 'bradgessler').should eql("hello jeannette gessler in spanish")
-    end
-  end
-  
-  context "context" do
-    it "should handle contexts and non-proc conditions" do
-      dispatch('HI BRAD 90').should eql("STOP SHOUTING WITH NUMBERS!")
-    end
-    
-    it "should handle nested contexts and proc conditions" do
-      dispatch('HI BRAD').should eql("STOP SHOUTING WITHOUT NUMBERS!")
+        main_router.call({}).should be_nil
+        $did_outer_run.should be_true
+        $did_inner_run.should be_nil
+      end
+
+      it "runs neither when inner matches and outer doesn't" do
+        $outer_matcher = false
+        $inner_matcher = true
+
+        main_router.call({}).should be_nil
+        $did_outer_run.should be_nil
+        $did_inner_run.should be_nil
+      end
+
+      context 'multiple inner matchers' do
+        before do
+          $outer_matcher_1 = $outer_matcher_2 = $inner_matcher_1 = $inner_matcher_2 = $did_outer_run_1 = $did_outer_run_2 = $did_inner_run_1 = $did_inner_run_2 = nil
+        end
+
+        def main_router
+          Class.new MessageRouter::Router do
+            # Define them
+            sub_router_1 = Class.new MessageRouter::Router do
+              match($inner_matcher_1) { $did_inner_run_1 = true }
+            end.new
+            sub_router_2 = Class.new MessageRouter::Router do
+              match($inner_matcher_2) { $did_inner_run_2 = true }
+            end.new
+
+            # 'mount' them
+            match $outer_matcher_1 do
+              $did_outer_run_1 = true
+              sub_router_1.call(env)
+            end
+
+            match $outer_matcher_2 do
+              $did_outer_run_2 = true
+              sub_router_2.call(env)
+            end
+          end.new
+        end
+
+        it "runs only 1st outer and 1st inner when all match" do
+          $outer_matcher_1 = $outer_matcher_2 = $inner_matcher_1 = $inner_matcher_2 = true
+
+          main_router.call({}).should be_true
+          $did_outer_run_1.should be_true
+          $did_outer_run_2.should be_nil
+          $did_inner_run_1.should be_true
+          $did_inner_run_2.should be_nil
+        end
+
+        it "runs both outers, and 2nd inner when all but 1st inner match" do
+          $outer_matcher_1 = $outer_matcher_2 = $inner_matcher_2 = true
+          $inner_matcher_1 = false
+
+          main_router.call({}).should be_true
+          $did_outer_run_1.should be_true
+          $did_outer_run_2.should be_true
+          $did_inner_run_1.should be_nil
+          $did_inner_run_2.should be_true
+        end
+
+      end
     end
-    
-    it "should pass arguments into contexts" do
-      dispatch('FUNNYWORD').should eql("Zeldzamar-1080")
+
+
+    describe 'helper methods' do
+      module MyTestHelper
+        LOOKUP = {
+          1 => 'John',
+          2 => 'Jim',
+          3 => 'Jules'
+        }
+        def lookup_human_name
+          env['human_name'] = LOOKUP[env['id']]
+        end
+      end
+
+      let :router do
+        Class.new MessageRouter::Router do
+          include MyTestHelper
+          match :lookup_human_name do
+            $is_john = env['human_name'] == 'John'
+          end
+
+          match 'run_a' => 'block' do
+            env['id'] = 2
+            env['the_name'] = lookup_human_name
+          end
+          match({'run_a' => 'proc'}, Proc.new do
+            env['id'] = 2
+            env['the_name'] = lookup_human_name
+          end)
+          match({'run_a' => 'lambda'}, lambda do
+            env['id'] = 2
+            env['the_name'] = lookup_human_name
+          end)
+
+          match(
+            Proc.new do
+              env['id'] = 3 if %w(proc lambda).include?(env['match_with'])
+              lookup_human_name
+            end
+           ) { true }
+        end.new
+      end
+
+      it 'can access/modify the env via #env' do
+        env = {'id' => 1}
+        router.call(env).should be_true
+        $is_john.should be_true            # Prove the inner matcher can see the new value
+        env['human_name'].should == 'John' # Prove we can get at the value after the router has finished.
+      end
+
+      it '#env is reset after #call has finished' do
+        router.call({'id' => 1}).should be_true
+        router.send(:env).should be_nil
+      end
+
+      %w(block proc lambda).each do |type|
+        it "can be accessed from a #{type} that is the 2nd argument" do
+          env = {'run_a' => type}
+          router.call(env).should be_true
+          env['the_name'].should == 'Jim'
+        end
+      end
+
+      %w(proc lambda).each do |type|
+        it "can be accessed from a #{type} that is the 1st argument" do
+          env = {'match_with' => type}
+          router.call(env).should be_true
+          env['human_name'].should == 'Jules'
+        end
+      end
     end
   end
-end
+end