message_router 0.1.1 → 0.1.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    message_router (0.1.1)
+    message_router (0.1.2)
 
 GEM
   remote: http://rubygems.org/

data/lib/message_router/router.rb

@@ -16,11 +16,17 @@ class MessageRouter
   #         Logger.error "Can't reply when when don't know who a message is from: #{env.inspect}"
   #       end
   #
+  #       # Matches if the first word of env['body'] is PING (case insensitive).
+  #       # Overwrite #default_attribute in your router to match against a
+  #       # different attribute.
   #       match 'ping' do
   #         PingCounter.increment!
   #         send_reply 'pong', env
   #       end
   #
+  #       # Matches if env['body'] matches the given Regexp.
+  #       # Overwrite #default_attribute in your router to match against a
+  #       # different attribute.
   #       match /\Ahelp/i do
   #         SupportQueue.contact_asap(env['from'])
   #         send_reply 'Looks like you need some help. Hold tight someone will call you soon.', env
@@ -271,8 +277,7 @@ class MessageRouter
 
       case should_i
       when Regexp, String
-        # TODO: Consider making this default attribute configurable.
-        normalize_match_params 'body' => should_i
+        normalize_match_params default_attribute => should_i
 
       when TrueClass, FalseClass, NilClass
         Proc.new { should_i }
@@ -299,7 +304,6 @@ class MessageRouter
         # Assume it already responds to #call.
         should_i
       end
-
     end
 
     def attr_matches?(attr, val)
@@ -316,5 +320,9 @@ class MessageRouter
         raise "Unexpected value '#{val.inspect}'. Should be String, Regexp, or Array of Strings and Regexps."
       end
     end
+
+    def default_attribute
+      'body'
+    end
   end
 end

data/lib/message_router/version.rb

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

data/spec/message_router_spec.rb

@@ -3,233 +3,263 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 # TODO: Maybe move this into a sub-directory
 describe MessageRouter::Router do
 
-  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
 
-    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
 
-        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 }
 
-        # 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
 
-            # 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
+      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
 
-        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 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 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 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 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 string to match against the 1st word in the message body' do
-          the_test.call :true => 'hello', :false => 'hell'
-        end
+      context 'the default attribute has been over-written' do
+        let(:router) do
+          Class.new MessageRouter::Router do
+            match('cheese') { env['result'] = 'i found cheese' }
+            match(/bean/)   { env['result'] = 'magical fruit' }
 
-        it 'accepts a symbol which is a method name' do
-          the_test.call :true => :always_true, :false => :always_false
+            def default_attribute
+              'tacos'
+            end
+          end.new
         end
 
-        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)
+        it 'accepts a string to match against the 1st word in the default attribute' do
+          env = { 'tacos' => 'cheese please' }
+          router.call(env).should be_true
+          env['result'].should == 'i found cheese'
+        end
+        it "does not match strings against the 'body' attribute" do
+          env = { 'body' => 'cheese please' }
+          router.call(env).should be_nil
         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
+        it 'accepts a regex to match against the default attribute' do
+          env = { 'tacos' => 'i like beans a lot' }
+          router.call(env).should be_true
+          env['result'].should == 'magical fruit'
+        end
+        it "does not match regex against the 'body' attribute" do
+          env = { 'body' => 'i like beans a lot' }
+          router.call(env).should be_nil
+        end
+      end
 
-            router.call({})
-            $run_count.should == 1
-          end
+      it 'accepts a symbol which is a method name' do
+        the_test.call :true => :always_true, :false => :always_false
+      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
+      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
 
-            router.call({}).should == nil
-          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
 
-        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 "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
 
-          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
+          router.call({}).should == nil
         end
+
       end
 
-      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
+      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 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
+        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 '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)
+        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 '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)
+        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
 
-      it 'defaults the 1st argument to true if only a block is given' do
+    describe '2nd argument' do
+      it 'accepts a Proc' do
         env = {}
         router = Class.new MessageRouter::Router do
-          match { env['did_it_run'] = true }
+          match(true, Proc.new { env['did_it_run'] = true })
         end.new
         router.call env
         env['did_it_run'].should be_true
       end
 
-      it 'defaults the 1st argument to true if only a Proc is given' do
+      it 'accepts a block' do
         env = {}
         router = Class.new MessageRouter::Router do
-          match(Proc.new { env['did_it_run'] = true })
+          match(true) { env['did_it_run'] = true }
         end.new
         router.call env
         env['did_it_run'].should be_true
       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
+      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 no arguments and no block is given' do
+      it 'raises an execption when neither a Proc nor a block are given' do
         lambda {
           router = Class.new MessageRouter::Router do
-            match
+            match true
           end.new
         }.should raise_error(ArgumentError)
       end
     end
+
+    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
+
+    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
+
+    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
+
+    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
 
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: message_router
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Brad Gessler
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-13 00:00:00 Z
+date: 2012-09-10 00:00:00 Z
 dependencies: []
 
 description: a DSL for routing SMS, Twitter, and other short message formats.