message_router 0.1.3 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41cf9f1df6c11508d36a7dda6cce51a70ba19f30
+  data.tar.gz: 8168d00903f7ee8255021d28c251876e56a9787c
+SHA512:
+  metadata.gz: 5f6ea5ea859997e69e646bb65d3505a2d7f65b51a73f22a3613bf91970fbf2890cc9ef99253f482b6ea9c424d6fd85c6ceb3a41ab16d43f3192b5befefb035fc
+  data.tar.gz: 9f06de8f00cce839914fdce6ed191e84c447d03ab0687ba948d2fb791943cb2428859efd7a06260ed0638b962f5d85ea45b1e2e2a5679e0af80d03c277e0078a

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1.3
+
+bundler_args: --without test development

data/Gemfile

@@ -1,12 +1,16 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in message_router.gemspec
 gemspec
 
-group :test, :development do
+group :ci, :test, :development do
   gem 'rspec'
-  gem 'rb-fsevent'
+  gem 'rake'
+end
+
+group :test, :development do
+  gem 'listen'
   gem 'growl'
   gem 'guard'
   gem 'guard-rspec'
-end
+end

data/Gemfile.lock

@@ -1,27 +1,58 @@
 PATH
   remote: .
   specs:
-    message_router (0.1.2)
+    message_router (0.2.0)
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.6)
+    formatador (0.2.5)
     growl (1.0.3)
-    guard (0.5.1)
-      thor (~> 0.14.6)
-    guard-rspec (0.4.0)
-      guard (>= 0.4.0)
-    rb-fsevent (0.4.2)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
-    thor (0.14.6)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.3.1)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    hitimes (1.2.2)
+    listen (2.7.11)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    slop (3.6.0)
+    thor (0.19.1)
+    timers (4.0.1)
+      hitimes
 
 PLATFORMS
   ruby
@@ -30,6 +61,7 @@ DEPENDENCIES
   growl
   guard
   guard-rspec
+  listen
   message_router!
-  rb-fsevent
+  rake
   rspec

data/Guardfile

@@ -1,8 +1,32 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard 'rspec', :version => 2, :cli => '--colour', :notification => true do
-  watch(%r{^spec/.+_spec\.rb})
-  watch(%r{^lib/(.+)\.rb})                      { |m| "spec/message_router_spec.rb" }
-  watch(/^spec\/spec_helper.rb/)                { "spec" }
-end
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  watch('spec/rails_helper.rb')                       { "spec" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end

data/README.rdoc

@@ -1,5 +1,8 @@
 = Message Router
 
+{<img src="https://travis-ci.org/polleverywhere/message_router.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/polleverywhere/message_router]
+{<img src="https://codeclimate.com/github/polleverywhere/message_router/badges/gpa.svg" />}[https://codeclimate.com/github/polleverywhere/message_router]
+
 Message router is a DSL for routing and processing simple messages, like SMS messages or Tweets.
 
 == Installation
@@ -12,30 +15,30 @@ See rdoc for MessageRouter::Router.build (lib/message_router/router.rb) for exam
 
 And now some irb action.
 
-    1.8.7 :001 > class HelloRouter < MessageRouter::Router
-    1.8.7 :002?>     match /hi/ do
-    1.8.7 :003 >           puts "Hi there. You sent me: #{env.inspect}"
-    1.8.7 :004?>         true # puts returns nil, and that would fail the matcher
-    1.8.7 :005?>       end
-    1.8.7 :006?>   end
-     => [[/hi/, #<Proc:0x00000000026963b8@(irb):2>]] 
-    1.8.7 :007 > HelloRouter.new.call({'body' => 'can you say hi to me?'})
-    Hi there. You sent me: {'body'=>"can you say hi to me?"}
-     => true 
-    1.8.7 :008 > class MainRouter < MessageRouter::Router
-    1.8.7 :009?>     match({'to' => 'greeter'}, HelloRouter.new)
-    1.8.7 :010?>     match(true) do
-    1.8.7 :011 >           puts "WTF? I don't know how to do that!"
-    1.8.7 :012?>         true # puts returns nil, and that would fail the matcher
-    1.8.7 :013?>       end
-    1.8.7 :014?>   end
-     => [[{:to=>"greeter"}, #<HelloRouter:0x25fef90 @rules=[[#<Proc:0x000000000266b2d0@/home/paul/sc/pe/message_router/lib/message_router/router.rb:165>, #<Proc:0x00000000026963b8@(irb):2>]]>], [true, #<Proc:0x00000000025ff580@(irb):10>]] 
-    1.8.7 :015 > MainRouter.new.call({'body' => 'can you say hi to me?'})
-    WTF? I don't know how to do that!
-     => true 
-    1.8.7 :016 > MainRouter.new.call({'body' => 'can you say hi to me?', 'to' => 'greeter'})
-    Hi there. You sent me: {'body'=>"can you say hi to me?", 'to'=>"greeter"}
-     => true 
+    class HelloRouter < MessageRouter::Router
+      match /hi/ do
+        puts "Hi there. You sent me: #{env.inspect}"
+        true # puts returns nil, and that would fail the matcher
+      end
+    end
+    # => [[/hi/, #<Proc:0x00000000026963b8@(irb):2>]]
+    HelloRouter.call({'body' => 'can you say hi to me?'})
+    # Hi there. You sent me: {'body'=>"can you say hi to me?"}
+    # => true
+    class MainRouter < MessageRouter::Router
+      match({'to' => 'greeter'}, HelloRouter)
+      match(true) do
+        puts "WTF? I don't know how to do that!"
+        true # puts returns nil, and that would fail the matcher
+      end
+    end
+    # => [[{"to"=>"greeter"}, HelloRouter], [true, #<Proc:0x007f98c39e5b70@(irb):13>]]
+    MainRouter.call({'body' => 'can you say hi to me?'})
+    # WTF? I don't know how to do that!
+    # => true
+    MainRouter.call({'body' => 'can you say hi to me?', 'to' => 'greeter'})
+    # Hi there. You sent me: {'body'=>"can you say hi to me?", 'to'=>"greeter"}
+    # => true
 
 
 == TODO
@@ -57,7 +60,7 @@ Add tests to ensure that instance variables can be shared between initializers a
         @sender.puts 'something'
       end
     end
-    MyRouter.new(:sender => STDOUT).call({})  # prints out 'something' to standard out.
+    MyRouter(:sender => STDOUT).call({})  # prints out 'something' to standard out.
 
 Pass Regexp captures on to the proc when there is a match. Examples:
     match /some (cool|awesome) thing/ do |match|
@@ -106,17 +109,17 @@ Make helper methods defined (or included) in parent routers available in sub rou
 Pass around copies of the env Hash instead of modifying the existing Hash in place.
 * This _might_ help with multi-threading
   * Perhaps a parent router wants to delegate to 2 sub-routers which are independent of each other. The current implementation has a shared env hash, so I couldn't use multi-threading, (though forking could work). I would have to trust the user to call #dup on at least one of the env hashes. With this new way, it is safe by default.
-* Convention would be for the 'should_i' Procs to return a copy of the env hashes, either modified or not, depending on their needs.
+* Convention would be for the 'condition' Procs to return a copy of the env hashes, either modified or not, depending on their needs.
   * They would still return nil or false if they don't match.
 * We could also require (by convention only) that sub-routers also return a copy of the env hash (if they succeed) so this (optionally modified) env hash can be used for further routing.
   * This would give the original router access to both the modified env hash and the original env hash.
 
-Find a way to allow user-defined 'do_this' procs/blocks to not have to return a true value to be considered to have matched. We still need a way to know if a sub-router matched or not. This _may_require that the code treat sub-routers and user-defined 'do_this' procs/blocks differently, which could get awkward.
+Find a way to allow user-defined 'action' procs/blocks to not have to return a true value to be considered to have matched. We still need a way to know if a sub-router matched or not. This _may_require that the code treat sub-routers and user-defined 'action' procs/blocks differently, which could get awkward.
 
 Allow routers to accept an optional logger. Depending on the log level, print out info such as:
 * When a matcher is registered
 * Each time a matcher is evaluated, including what the return value was.
-* Each time a 'do_this' block is evaluated, including what the return value was.
+* Each time a 'action' block is evaluated, including what the return value was.
 Each time we write to the log include the following (depending on the log level):
 * The value of the env hash
 * The name of the class (so we can tell which subclass we are in)
@@ -132,21 +135,21 @@ Consider having a class called Run nested within the router's namespace. Instead
     end
 Run#run might look something like:
     def run
-      router.rules.detect do |should_i, do_this|
-        should_i = if should_i.kind_of?(Proc)
-          self.instance_eval &should_i
+      router.rules.detect do |condition, action|
+        condition = if condition.kind_of?(Proc)
+          self.instance_eval &condition
         else
-          should_i.call env
+          condition.call env
         end
 
-        if should_i
-          do_this = if do_this.kind_of?(Proc)
-            self.instance_eval &do_this
+        if condition
+          action = if action.kind_of?(Proc)
+            self.instance_eval &action
           else
-            do_this.call env
+            action.call env
           end
 
-          return do_this if do_this
+          return action if action
         end
       end
     end

data/lib/message_router/router.rb

@@ -8,11 +8,11 @@ class MessageRouter
   #
   #       prerequisite :db_connected?
   #
-  #       match SomeOtherRouter.new
+  #       match SomeOtherRouter
   #       # `mount` is an alias of `match`
-  #       mount AnotherRouter.new
+  #       mount AnotherRouter
   #
-  #       match(lamba { env['from'].nil? }) do
+  #       match(lambda { env['from'].nil? }) do
   #         Logger.error "Can't reply when when don't know who a message is from: #{env.inspect}"
   #       end
   #
@@ -40,13 +40,13 @@ class MessageRouter
   #         send_reply "Sorry, you are trying to use a deprecated short code. Please try again.", env
   #       end
   #
-  #       match :user_name => PriorityUsernameRouter.new
-  #       match :user_name, OldStyleUsernameRouter.new
+  #       match :user_name => PriorityUsernameRouter
+  #       match :user_name, OldStyleUsernameRouter
   #       match :user_name do
   #         send_reply "I found you! Your name is #{user_name}.", env
   #       end
   #
-  #       match %w(stop end quit), StopRouter.new
+  #       match %w(stop end quit), StopRouter
   #
   #       # Array elements don't need to be the same type
   #       match [
@@ -54,7 +54,7 @@ class MessageRouter
   #         {'to' => %w(12345 54321)},
   #         {'RAILS_ENV' => 'test'},
   #         'test'
-  #       ], TestRouter.new
+  #       ], TestRouter
   #
   #       # Works inside a Hash too
   #       match 'from' => ['12345', '54321', /111\d\d/] do
@@ -80,7 +80,7 @@ class MessageRouter
   #       end
   #     end
   #
-  #     router = MyApp::Router::Application.new
+  #     router = MyApp::Router::Application
   #     router.call({})  # Logs an error about not knowing who the message is from
   #     router.call({'from' => 'mr-smith', 'body' => 'ping'})  # Sends a 'pong' reply
   #     router.call({'from' => 'mr-smith', 'to' => 12345})     # Sends a deprecation warning reply
@@ -149,28 +149,31 @@ class MessageRouter
         when 0
           raise ArgumentError, "You must provide either a block or an argument which responds to call."
         when 1
-          if args[0].respond_to?(:call)
-            should_i = true
-            do_this  = args[0]
+          if args[0].respond_to?(:env)
+            condition = true
+            action  = args[0]
+          elsif args[0].respond_to?(:call)
+            condition = true
+            action  = args[0]
           elsif args[0].kind_of?(Hash) && args[0].values.size == 1 && args[0].values[0].respond_to?(:call)
             # Syntactical suger to make:
-            #     match :cool? => OnlyForCoolPeopleRouter.new
+            #     match :cool? => OnlyForCoolPeopleRouter
             # work just like:
-            #     match :cool?, OnlyForCoolPeopleRouter.new
-            should_i = args[0].keys[0]
-            do_this  = args[0].values[0]
+            #     match :cool?, OnlyForCoolPeopleRouter
+            condition = args[0].keys[0]
+            action  = args[0].values[0]
           else
             raise ArgumentError, "You must provide either a block or a 2nd argument which responds to call."
           end
         when 2
-          should_i, do_this = args
-          raise ArgumentError, "The 2nd argument must respond to call." unless do_this.respond_to?(:call)
+          condition, action = args
+          raise ArgumentError, "The 2nd argument must respond to call." unless action.respond_to?(:call)
         else
           raise ArgumentError, "Too many arguments. Note: you may not provide a block when a 2nd argument has been provided."
         end
 
         # Save the arguments for later.
-        rules << [should_i, do_this]
+        rules << [condition, action]
       end
       alias :mount :match
 
@@ -193,13 +196,34 @@ class MessageRouter
       def prerequisites
         @prerequisites ||= []
       end
+
+      # Kicks off the router. 'env' is a Hash. The keys are up to the user;
+      # however, the default key (used when a matcher is just a String or Regexp)
+      # is 'body'. If you don't specify this key, then String and Regexp matchers
+      # will always be false.
+      # Returns a new instance of this class, that gets run before being returned
+      # A rule "matches" if its condition return true and the action does not
+      # explicitly call not_matched. For example:
+      #     match(true) { }
+      # matches. However:
+      #     match(true) { not_matched }
+      # does not count as a match. This allows us to mount sub-routers and
+      # continue trying other rules if those subrouters fail to match something.
+      def call(env)
+        new(env).run
+      end
     end
 
 
     # This method initializes all the rules stored at the class level. When you
     # create your subclass, if you want to add your own initializer, it is very
     # important to call `super` or none of your rules will be matched.
-    def initialize
+    def initialize(env) #:nodoc:
+      @env = env.dup
+      # a parent router may be assuming a successful match
+      # but this subrouter may not, so we explicitly set it to not matched
+      # on creation
+      not_matched
       @rules = []
       # Actually create the rules so that the procs we create are in the
       # context of an instance of this object. This is most important when the
@@ -209,100 +233,96 @@ class MessageRouter
       self.class.rules.each {|rule| match *rule }
 
       @prerequisites = []
-      self.class.prerequisites.each {|prerequisite| @prerequisites << normalize_match_params(prerequisite) }
+      self.class.prerequisites.each do |prerequisite|
+        @prerequisites << normalize_match_params(prerequisite)
+      end
     end
 
-    # Kicks off the router. 'env' is a Hash. The keys are up to the user;
-    # however, the default key (used when a matcher is just a String or Regexp)
-    # is 'body'. If you don't specify this key, then String and Regexp matchers
-    # will always be false.
-    # Returns nil if no rules match
-    # Returns true if a rule matches
-    # A rule "matches" if both its procs return true. For example:
-    #     match(true) { true }
-    # matches. However:
-    #     match(true) { false }
-    # does not count as a match. This allows us to mount sub-routers and
-    # continue trying other rules if those subrouters fail to match something.
-    # However, this does mean you need to be careful when writing the 2nd
-    # argument to #match. If you return nil or false, the router will keep
-    # looking for another match.
-    def call(env)
-      # I'm pretty sure this is NOT thread safe. Having two threads use the
-      # same router at the same time will almost certainly give you VERY weird
-      # and incorrect results. We may want to introduce a RouterRun object to
-      # encapsulate one invocation of this #call method.
-      @env = env
-
+    def run #:nodoc:
       # All prerequisites must return true in order to continue.
-      return false unless @prerequisites.all? do |should_i|
-        if should_i.kind_of?(Proc)
-          self.instance_eval &should_i
-        else
-          should_i.call @env
-        end
+      return self unless @prerequisites.all? do |condition|
+        self.instance_eval &condition
       end
 
-      @rules.detect do |should_i, do_this|
-        should_i = if should_i.kind_of?(Proc)
-          self.instance_eval &should_i
-        else
-          should_i.call @env
+      @rules.detect do |condition, action|
+        if self.instance_eval &condition
+          matched
+          r = self.instance_eval &action
+          @env = r.respond_to?(:env) ? r.env : r
+          return self if matched?
         end
+      end
 
-        if should_i
-          do_this = if do_this.kind_of?(Proc)
-            self.instance_eval &do_this
-          else
-            do_this.call @env
-          end
+      self # always return router instance
+    end
 
-          return true if do_this
-        end
-      end
-    ensure
-      @env = nil
+    def not_matched
+      env['_matched'] = false
+    end
+    def matched
+      env['_matched'] = true
+    end
+    def matched?
+      !!env['_matched']
     end
 
 
-    private
     def env; @env; end
+    private
 
-    def match(should_i, do_this)
-      @rules << [normalize_match_params(should_i), do_this]
+    def match(condition, action)
+      @rules << [normalize_match_params(condition), normalize_action(action)]
+    end
+
+    def normalize_action(action)
+      if action.kind_of?(Proc) # This is true for blocks and lamdas too.
+        Proc.new do
+          self.instance_eval &action
+          env
+        end
+      else
+        Proc.new do
+          action.call(env)
+        end
+      end
     end
 
-    def normalize_match_params(should_i=nil, &block)
-      should_i ||= block if block
+    def normalize_match_params(condition=nil, &block)
+      condition ||= block if block
 
-      case should_i
+      case condition
       when Regexp, String
-        Proc.new { attr_matches? default_attribute, should_i }
+        Proc.new { attr_matches? default_attribute, condition }
 
       when TrueClass, FalseClass, NilClass
-        Proc.new { should_i }
+        Proc.new { condition }
 
       when Symbol
         Proc.new do
-          self.send should_i
+          self.send condition
         end
 
       when Array
-        should_i = should_i.map {|x| normalize_match_params x}
+        condition = condition.map {|x| normalize_match_params x}
         Proc.new do
-          should_i.any? { |x| x.call env }
+          condition.any? { |x| x.call env }
         end
 
       when Hash
         Proc.new do
-          should_i.all? do |key, val|
+          condition.all? do |key, val|
             attr_matches? env[key], val
           end
         end
 
+      when Proc
+        condition
+
       else
         # Assume it already responds to #call.
-        should_i
+        Proc.new do
+          condition.call env
+        end
       end
     end
 

data/lib/message_router/version.rb

@@ -1,3 +1,3 @@
 class MessageRouter
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 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", "Paul Cortens"]
-  s.email       = ["brad@bradgessler.com", "paul@thoughtless.ca"]
+  s.authors     = ["Brad Gessler", "Paul Cortens", "Christopher Bertels"]
+  s.email       = ["brad@bradgessler.com", "paul@thoughtless.ca", "bakkdoor@flasht.de"]
   s.homepage    = ""
   s.summary     = %q{Route messages}
   s.description = %q{a DSL for routing SMS, Twitter, and other short message formats.}

data/spec/message_router_spec.rb

@@ -5,11 +5,6 @@ describe MessageRouter::Router 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',
@@ -19,10 +14,10 @@ describe MessageRouter::Router do
       end
 
       # This needs to be a method (and not memoized by #let) so that
-      # $thing_to_match can change within a test.
-      def router
+      # thing_to_match can change within a test.
+      def router(thing_to_match)
         Class.new MessageRouter::Router do
-          match($thing_to_match) { $did_it_run = true }
+          match(thing_to_match) { env['did_it_run'] = true }
 
           # Using these methods also proves that the message is optionally
           # passed to helper methods.
@@ -32,20 +27,16 @@ describe MessageRouter::Router do
           def always_false
             false
           end
-        end.new
+        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
+          r = router(opts[:true]).call(env.dup)
+          expect(r.env['did_it_run']).to eq true
 
-          $thing_to_match = opts[:false]
-          router.call(env)
-          $did_it_run.should == nil
-          $did_it_run = nil # reset for next time
+          r = router(opts[:false]).call(env.dup)
+          expect(r.env['did_it_run']).to eq nil
         end
       end
 
@@ -82,27 +73,27 @@ describe MessageRouter::Router do
             def default_attribute
               env['tacos']
             end
-          end.new
+          end
         end
 
         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'
+          r = router.call({ 'tacos' => 'cheese please' })
+          expect(r.matched?).to be_truthy
+          expect(r.env['result']).to eq 'i found cheese'
         end
         it "does not match strings against the 'body' attribute" do
-          env = { 'body' => 'cheese please' }
-          router.call(env).should be_nil
+          r = router.call({ 'body' => 'cheese please' })
+          expect(r.matched?).to be_falsey
         end
 
         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'
+          r = router.call({ 'tacos' => 'i like beans a lot' })
+          expect(r.matched?).to be_truthy
+          expect(r.env['result']).to eq '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
+          r = router.call({ 'body' => 'i like beans a lot' })
+          expect(r.matched?).to be_falsey
         end
       end
 
@@ -115,31 +106,18 @@ describe MessageRouter::Router do
       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
+        it "doesn't run the 'action' block multiple times if there are multiple matches" do
+          run = double
+          expect(run).to receive(:count).once
           router = Class.new(MessageRouter::Router) do
             match [true, true] do
-              $run_count += 1
-              nil # Return nil to ensure this matcher failed.
+              run.count
+              not_matched
             end
-          end.new
-
-          router.call({}).should == nil
+          end
+          r = router.call({})
+          expect(r.matched?).to be_falsey
         end
-
       end
 
       describe 'matching a hash' do
@@ -181,10 +159,8 @@ describe MessageRouter::Router do
         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
+          r = router({'i dont exist' => /.*/}).call(env)
+          expect(r.env['did_it_run']).to eq nil
         end
       end
     end
@@ -194,34 +170,34 @@ describe MessageRouter::Router do
         env = {}
         router = Class.new MessageRouter::Router do
           match(true, Proc.new { env['did_it_run'] = true })
-        end.new
+        end
         router.call env
-        env['did_it_run'].should be_true
+        expect(env['did_it_run']).to be_truthy
       end
 
       it 'accepts a block' do
         env = {}
         router = Class.new MessageRouter::Router do
           match(true) { env['did_it_run'] = true }
-        end.new
+        end
         router.call env
-        env['did_it_run'].should be_true
+        expect(env['did_it_run']).to be_truthy
       end
 
       it 'raises an execption when both a Proc and a block are given' do
-        lambda {
+        expect {
           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
+        }.to raise_error(ArgumentError)
       end
 
       it 'raises an execption when neither a Proc nor a block are given' do
-        lambda {
+        expect {
           router = Class.new MessageRouter::Router do
             match true
-          end.new
-        }.should raise_error(ArgumentError)
+          end
+        }.to raise_error(ArgumentError)
       end
     end
 
@@ -229,18 +205,18 @@ describe MessageRouter::Router do
       env = {}
       router = Class.new MessageRouter::Router do
         match { env['did_it_run'] = true }
-      end.new
+      end
       router.call env
-      env['did_it_run'].should be_true
+      expect(env['did_it_run']).to be_truthy
     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
+      end
       router.call env
-      env['did_it_run'].should be_true
+      expect(env['did_it_run']).to be_truthy
     end
 
     it 'accepts a Hash with a symbol as its only key and a Proc as its only value' do
@@ -248,41 +224,41 @@ describe MessageRouter::Router do
       router = Class.new MessageRouter::Router do
         match :true_method => (Proc.new { env['did_it_run'] = true })
         def true_method; true; end
-      end.new
+      end
       router.call env
-      env['did_it_run'].should be_true
+      expect(env['did_it_run']).to be_truthy
     end
 
     it 'raises an execption when no arguments and no block is given' do
-      lambda {
+      expect {
         router = Class.new MessageRouter::Router do
           match
-        end.new
-      }.should raise_error(ArgumentError)
+        end
+      }.to raise_error(ArgumentError)
     end
   end
 
 
   describe "#call" do
-    it "returns nil with no rules" do
-      r = MessageRouter::Router.new
-      r.call({}).should be_nil
+    it "does not match with no rules" do
+      router = MessageRouter::Router.call({})
+      expect(router.matched?).to be_falsey
     end
 
     context 'a rule matches' do
       subject do
         Class.new MessageRouter::Router do
           match(true) { env[:did_it_run] = true }
-        end.new
+        end
       end
 
       it "returns true" do
-        subject.call({}).should be_true
+        expect(subject.call({})).to be_truthy
       end
 
       it "calls the matcher's code" do
-        subject.call(env = {})
-        env[:did_it_run].should be_true
+        r = subject.call(env = {})
+        expect(r.env[:did_it_run]).to be_truthy
       end
     end
 
@@ -292,16 +268,16 @@ describe MessageRouter::Router do
           prerequisite :true_method
           match(true) { env[:did_it_run] = true }
           def true_method; true; end
-        end.new
+        end
       end
 
-      it "returns true" do
-        subject.call({}).should be_true
+      it "matches" do
+        expect(subject.call({}).matched?).to be_truthy
       end
 
       it "calls the matcher's code" do
-        subject.call(env = {})
-        env[:did_it_run].should be_true
+        r = subject.call(env = {})
+        expect(r.env[:did_it_run]).to be_truthy
       end
     end
 
@@ -311,112 +287,126 @@ describe MessageRouter::Router do
           prerequisite :false_method
           match(true) { env[:did_it_run] = true }
           def false_method; false; end
-        end.new
+        end
       end
 
-      it "returns false" do
-        subject.call({}).should be_false
+      it "doesn't match" do
+        expect(subject.call({}).matched?).to be_falsey
       end
 
       it "doesn't calls the matcher's code" do
         subject.call(env = {})
-        env[:did_it_run].should_not be_true
+        expect(env[:did_it_run]).to_not be_truthy
       end
     end
 
-    describe 'nested routers' do
-      def main_router
+    describe 'mount routers' do
+      it "can delegate to other routers" do
+        sub_router = Class.new(MessageRouter::Router) do
+          match do
+            env['result'] = true
+          end
+        end
+
+        main_router = Class.new(MessageRouter::Router) do
+          mount sub_router
+        end
+
+        r = main_router.call({})
+        expect(r.env['result']).to eq true
+      end
+    end
+
+    describe "explicitly not matching" do
+      let(:router) do
         Class.new(MessageRouter::Router) do
-          sub_router = Class.new(MessageRouter::Router) do
-            match($inner_matcher) { $did_inner_run = true }
-          end.new
+          match do
+            not_matched
+          end
+        end
+      end
 
-          match $outer_matcher do
-            $did_outer_run = true
-            sub_router.call(env)
+      it "sets matched to false in env" do
+        r = router.call({})
+        expect(r.matched?).to be_falsey
+      end
+    end
+
+    describe "explicitly matching" do
+      let(:router) do
+        Class.new(MessageRouter::Router) do
+          match do
+            not_matched
           end
-        end.new
+          match do
+            matched
+          end
+        end
       end
 
-      before do
-        $outer_matcher = $inner_matcher = $did_outer_run = $did_inner_run = nil
+      it "sets matched to true in env" do
+        r = router.call({})
+        expect(r.matched?).to be_truthy
       end
+    end
 
-      it 'runs both when both match' do
-        $outer_matcher = $inner_matcher = true
+    describe 'nested routers' do
+      def main_router(matcher_opts = {})
+        Class.new(MessageRouter::Router) do
+          sub_router = Class.new(MessageRouter::Router) do
+            match { not_matched; env['did_outer_run'] = true }
+            match(matcher_opts[:inner]) { env['did_inner_run'] = true }
+          end
 
-        main_router.call({}).should be_true
-        $did_outer_run.should be_true
-        $did_inner_run.should be_true
+          match matcher_opts[:outer] => sub_router
+        end
       end
 
-      it "runs outer only when outer matches and inner doesn't" do
-        $outer_matcher = true
-        $inner_matcher = false
+      it 'runs both when both match' do
+        r = main_router(:outer => true, :inner => true).call({})
+        expect(r.env['did_outer_run']).to be_truthy
+        expect(r.env['did_inner_run']).to be_truthy
+      end
 
-        main_router.call({}).should be_nil
-        $did_outer_run.should be_true
-        $did_inner_run.should be_nil
+      it "runs outer only when outer matches and inner doesn't" do
+        r = main_router(:outer => true, :inner => false).call({})
+        expect(r.env['did_outer_run']).to be_truthy
+        expect(r.env['did_inner_run']).to 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
+        r = main_router(:outer => false, :inner => true).call({})
+        expect(r.env['did_outer_run']).to be_nil
+        expect(r.env['did_inner_run']).to 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
+        def main_router(inner_matcher_1)
           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
+              match(inner_matcher_1) { env['did_inner_run_1'] = true }
+            end
             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)
+              match(true) { env['did_inner_run_2'] = true }
             end
 
-            match $outer_matcher_2 do
-              $did_outer_run_2 = true
-              sub_router_2.call(env)
-            end
-          end.new
+            mount sub_router_1
+            mount sub_router_2
+          end
         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
+          r = main_router(true).call({})
+          expect(r.env['did_inner_run_1']).to eq true
+          expect(r.env['did_inner_run_2']).to eq 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
+          r = main_router(false).call({})
+          expect(r.env['did_inner_run_1']).to be_nil
+          expect(r.env['did_inner_run_2']).to be_truthy
         end
-
       end
     end
 
@@ -437,7 +427,7 @@ describe MessageRouter::Router do
         Class.new MessageRouter::Router do
           include MyTestHelper
           match :lookup_human_name do
-            $is_john = env['human_name'] == 'John'
+            env['is_john'] = env['human_name'] == 'John'
           end
 
           match 'run_a' => 'block' do
@@ -448,7 +438,7 @@ describe MessageRouter::Router do
             env['id'] = 2
             env['the_name'] = lookup_human_name
           end)
-          match({'run_a' => 'lambda'}, lambda do
+          match({'run_a' => 'lambda'}, lambda do |args|
             env['id'] = 2
             env['the_name'] = lookup_human_name
           end)
@@ -459,34 +449,53 @@ describe MessageRouter::Router do
               lookup_human_name
             end
            ) { true }
-        end.new
+        end
       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
+        r = router.call({'id' => 1})
+        expect(r.matched?).to be_truthy
+        expect(r.env['is_john']).to be_truthy    # Prove the inner matcher can see the new value
+        expect(r.env['human_name']).to eq 'John' # Prove we can get at the value after the router has finished.
       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'
+          r = router.call({'run_a' => type})
+          expect(r.matched?).to be_truthy
+          expect(r.env['the_name']).to eq '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'
+          r = router.call({'match_with' => type})
+          expect(r.matched?).to be_truthy
+          expect(r.env['human_name']).to eq 'Jules'
+        end
+      end
+
+      describe "instance variables" do
+        let :router do
+          Class.new MessageRouter::Router do
+            prerequisite :helper_method
+
+            match do
+              env['result'] = @helper_method
+            end
+
+            private
+            def helper_method
+              @helper_method ||= 0
+              @helper_method += 1
+            end
+          end
+        end
+
+        it "doesn't leak state to a 2nd run" do
+          router.call({})
+          r = router.call({})
+          expect(r.env['result']).to eq 1
         end
       end
     end

metadata

@@ -1,37 +1,29 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: message_router
-version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 3
-  version: 0.1.3
+version: !ruby/object:Gem::Version
+  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Brad Gessler
 - Paul Cortens
+- Christopher Bertels
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-09-10 00:00:00 Z
+date: 2014-10-21 00:00:00.000000000 Z
 dependencies: []
-
 description: a DSL for routing SMS, Twitter, and other short message formats.
-email: 
+email:
 - brad@bradgessler.com
 - paul@thoughtless.ca
+- bakkdoor@flasht.de
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .rvmrc
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -45,38 +37,30 @@ files:
 - spec/message_router_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-homepage: ""
+homepage: ''
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: message_router
-rubygems_version: 1.8.22
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Route messages
-test_files: []
-
+test_files:
+- spec/message_router_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb

data/.rvmrc

@@ -1 +0,0 @@
-rvm use --install ree