lspace 0.7 → 0.8

data/lib/lspace/class_methods.rb

@@ -16,7 +16,11 @@ class LSpace
   # @param [Proc] block  The logical block that will be run in the clean LSpace
   # @see LSpace.enter
   def self.clean(&block)
-    enter new({}, nil), &block
+    if block_given?
+      enter new({}, nil), &block
+    else
+      new({}, nil)
+    end
   end
 
   # Create a new LSpace with the given keys set to the given values, and run the

data/lib/lspace/eventmachine.rb

@@ -28,6 +28,31 @@ module EventMachine
         s
       end
     end
+
+    # By default EM::run will temporarily switch to a clean LSpace to ensure
+    # that all your around_filters are run for every block executed on the
+    # reactor.
+    #
+    # If you don't want this behaviour, you can call EM.run_in_current_lspace
+    # which will continue using the current lspace.
+    alias_method :run_in_current_lspace, :run
+
+    # Override run to ensure that the LSpace context is re-entered more
+    # appropriately.
+    #
+    # This ensures that all blocks scheduled on the eventmachine reactor will
+    # be wrapped in the around_filters you define, and makes implementing things
+    # like a global error handler, or em-monitor a little easier.
+    def run(*args, &block)
+      lspace = LSpace.current
+      LSpace.clean do
+        run_in_current_lspace(*args) do |*a, &b|
+          lspace.enter do
+            block.call *a, &b if block_given?
+          end
+        end
+      end
+    end
   end
 
   # Many EM APIs (e.g. em-http-request) are based on deferrables. Preserving lspace for

data/lspace.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "lspace"
-  s.version = "0.7"
+  s.version = "0.8"
   s.platform = Gem::Platform::RUBY
   s.author = "Conrad Irwin"
   s.email = "conrad.irwin@gmail.com"

data/spec/eventmachine_spec.rb

@@ -132,5 +132,39 @@ describe LSpace do
       $server.should == [[:post_init, :server, :baz], [:receive_data, :server, :baz], [:unbind, :server, :baz]]
       $tick.should == [[:tick, :baz]]
     end
+
+    it "should ensure that around_filters defined outside EM::run are run on each callback inside the reactor" do
+      LSpace[:count] = 0
+      LSpace.around_filter do |&block|
+        LSpace[:count] += 1
+        block.call
+      end
+
+      LSpace[:count].should == 0
+      EM::run do
+        LSpace[:count].should == 1
+        EM::next_tick do
+          LSpace[:count].should == 2
+          EM::stop
+        end
+      end
+    end
+
+    it "should not re-enter LSpace if run_in_current_lspace is used" do
+      LSpace[:count] = 0
+      LSpace.around_filter do |&block|
+        LSpace[:count] += 1
+        block.call
+      end
+
+      LSpace[:count].should == 0
+      EM::run_in_current_lspace do
+        LSpace[:count].should == 0
+        EM::next_tick do
+          LSpace[:count].should == 0
+          EM::stop
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lspace
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
   prerelease: 
 platform: ruby
 authors: