lspace 0.1.pre.1 → 0.1

data/spec/eventmachine_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe LSpace do
+  describe "eventmachine integration" do
+    before do
+      $foo = :fail
+    end
+
+    it "should preserve LSpace in deferrable callbacks" do
+      d = Class.new{ include EM::Deferrable }.new
+      LSpace.update(:foo => 2) do
+        d.callback do
+          $foo = LSpace[:foo]
+        end
+      end
+      d.succeed
+      $foo.should == 2
+    end
+
+    it "should preserve LSpace in deferrable errbacks" do
+      d = Class.new{ include EM::Deferrable }.new
+      LSpace.update(:foo => 2) do
+        d.errback do
+          $foo = LSpace[:foo]
+        end
+      end
+      d.fail
+      $foo.should == 2
+    end
+
+    it "should preserve LSpace in EM::defer operation" do
+      EM::run do
+        LSpace.update(:foo => 4) do
+          EM::defer(lambda{
+            $foo = LSpace[:foo]
+          }, proc{
+            EM::stop
+          })
+        end
+      end
+      $foo.should == 4
+    end
+
+    it "should preserve LSpace in EM::defer callback" do
+      EM::run do
+        LSpace.update(:foo => 4) do
+          EM::defer(lambda{
+            nil
+          }, proc{
+            $foo = LSpace[:foo]
+            EM::stop
+          })
+        end
+      end
+      $foo.should == 4
+    end
+
+    it "should preserve LSpace in EM.next_tick" do
+      EM::run do
+        EM::next_tick do
+          LSpace.update :foo => 5 do
+            EM::next_tick do
+              $foo = LSpace[:foo]
+              EM::stop
+            end
+          end
+        end
+
+        EM::next_tick do
+          LSpace[:foo].should_not == 5
+        end
+      end
+      $foo.should == 5
+    end
+
+    it "should preserve LSpace in all connection callbacks" do
+      $server = []
+      $client = []
+      server = Module.new do
+        def setup_lspace
+          LSpace[:foo] = :server
+        end
+
+        def post_init
+          $server << [:post_init, LSpace[:foo], LSpace[:bar]]
+        end
+
+        def receive_data(data)
+          $server << [:receive_data, LSpace[:foo], LSpace[:bar]]
+          send_data(data)
+          close_connection_after_writing
+        end
+
+        def unbind
+          $server << [:unbind, LSpace[:foo], LSpace[:bar]]
+        end
+      end
+
+      client = Module.new do
+        def setup_lspace
+          LSpace[:foo] = :client
+        end
+
+        def post_init
+          $client << [:post_init, LSpace[:foo], LSpace[:bar]]
+          send_data("Hi world\n")
+        end
+
+        def receive_data(data)
+          data.should == "Hi world\n"
+          $client << [:receive_data, LSpace[:foo], LSpace[:bar]]
+        end
+
+        def unbind
+          $client << [:unbind, LSpace[:foo], LSpace[:bar]]
+          EM::stop
+        end
+      end
+
+      LSpace.update(:bar => :baz) do
+        EM::run do
+          EM::start_server '0.0.0.0', 9345, server
+          EM::connect '127.0.0.1', 9345, client
+        end
+      end
+
+      $client.should == [[:post_init, :client, :baz], [:receive_data, :client, :baz], [:unbind, :client, :baz]]
+      $server.should == [[:post_init, :server, :baz], [:receive_data, :server, :baz], [:unbind, :server, :baz]]
+    end
+  end
+end

data/spec/lspace_spec.rb

@@ -1,89 +1,150 @@
 require 'spec_helper'
 
 describe LSpace do
-  it "should act like a hash" do
-    LSpace[:foo] = 1
-    LSpace[:foo].should == 1
+  before do
+    @lspace = LSpace.new({:foo => 1}, nil)
   end
 
-  it "should isolate changes to nested spaces" do
-    LSpace[:foo] = 2
+  describe "#[]" do
+    it "should act like a hash" do
+      @lspace[:foo].should == 1
+    end
 
-    LSpace.new do
-      LSpace[:foo] = 1
-      LSpace[:foo].should == 1
+    it "should fall back to the parent" do
+      lspace2 = LSpace.new({:bar => 2}, @lspace)
+      lspace2[:foo].should == 1
     end
 
-    LSpace[:foo].should == 2
+    it "should use the child in preference to the parent" do
+      lspace2 = LSpace.new({:foo => 2}, @lspace)
+      lspace2[:foo].should == 2
+    end
   end
 
-  it "should fallback to outer spaces" do
-    LSpace[:bar] = 1
-    LSpace.new do
-      LSpace[:bar].should == 1
+  describe "#[]=" do
+    it "should act like a hash" do
+      @lspace[:foo] = 7
+      @lspace[:foo].should == 7
     end
-  end
 
-  it "should be isolated between different threads" do
-    LSpace[:foo] = 1
-    Thread.new{ LSpace[:foo].should == nil }.join
+    it "should not affect the parent" do
+      lspace2 = LSpace.new({}, @lspace)
+      lspace2[:foo] = 7
+      @lspace[:foo].should == 1
+    end
   end
 
-  it "should be isolated between different fibers" do
-    LSpace[:foo] = 1
-    Fiber.new{ LSpace[:foo].should == nil }.resume
-  end
+  describe "#around_filter" do
+    before do
+      @entered = 0
+      @returned = 0
 
-  it "should allow preserving spaces" do
-    p = LSpace.new(:foo => 1){ proc{ LSpace[:foo] }.in_lspace }
-    p.call.should == 1
-  end
+      @lspace.around_filter do |&block|
+        @entered += 1
+        begin
+          block.call
+        ensure
+          @returned += 1
+        end
+      end
+    end
 
-  it "should allow resuming spaces in different threads" do
-    p = LSpace.new(:foo => 1){ proc{ LSpace[:foo] }.in_lspace }
-    Thread.new{ p.call.should == 1 }.join
-  end
+    it "should be run when the LSpace is entered" do
+      LSpace.enter @lspace do
+        @entered.should == 1
+        @returned.should == 0
+      end
+      @returned.should == 1
+    end
+
+    it "should not be run when the LSpace is re-entered" do
+      LSpace.enter @lspace do
+        LSpace.enter @lspace do
+          @entered.should == 1
+        end
+      end
+    end
+
+    it "should not be re-run when a child of the LSpace is entered" do
+      lspace2 = LSpace.new({}, @lspace)
+
+      LSpace.enter @lspace do
+        lspace2.enter do
+          @entered.should == 1
+        end
+      end
+    end
 
-  it "should allow resuming spaces in different fibers" do
-    p = LSpace.new(:foo => 1){ LSpace.preserve{ LSpace[:foo] } }
-    Fiber.new{ p.call.should == 1 }.resume
+    it "should apply around_filters from first to last" do
+      called = []
+      @lspace.around_filter do |&block|
+        called << :first
+        block.call
+      end
+      @lspace.around_filter do |&block|
+        called << :last
+        block.call
+      end
+
+      LSpace.enter @lspace do
+        called.should == [:first, :last]
+      end
+    end
+
+    it "should apply around_filters from parents before children" do
+      called = []
+      @lspace.around_filter do |&block|
+        called << :first
+        block.call
+      end
+      lspace2 = LSpace.new({}, @lspace)
+      lspace2.around_filter do |&block|
+        called << :last
+        block.call
+      end
+
+      LSpace.enter lspace2 do
+        called.should == [:first, :last]
+      end
+    end
   end
 
-  it "should clean up lspace after resuming" do
-    p = LSpace.new(:foo => 1){ proc{ LSpace[:foo] }.in_lspace }
-    p.call.should == 1
-    LSpace[:foo].should == nil
+  describe "#enter" do
+    it "should delegate to LSpace" do
+      LSpace.should_receive(:enter).once.with(@lspace)
+      @lspace.enter do
+        5 + 5
+      end
+    end
   end
 
-  it "should resume the entire nested lspace" do
-    p = LSpace.new(:foo => 1) {
-          LSpace.new(:bar => 2) {
-            LSpace.new(:baz => 3) {
-              lambda &LSpace.preserve{ LSpace[:foo] + LSpace[:bar] + LSpace[:baz] }
-            }
-          }
-        }
+  describe "#wrap" do
+    it "should cause the LSpace to be entered when the block is called" do
+      @lspace.wrap{ LSpace.current.should == @lspace }.call
+    end
 
-    p.call.should == 6
-  end
+    it "should revert the changed LSpace at the end of the block" do
+      lspace = LSpace.current
+      @lspace.wrap{ LSpace.current.should == @lspace }.call
+      LSpace.current.should == lspace
+    end
 
-  it "should return to enclosing lspace after re-entering new lspace" do
-    LSpace.new(:baz => 1) do
-      p = LSpace.new(:baz => 2){ proc{ LSpace[:baz] }.in_lspace }
-      p.call.should == 2
-      LSpace[:baz].should == 1
+    it "should be possible to call the block on a different thread" do
+      todo = @lspace.wrap{ LSpace.current.should == @lspace }
+      Thread.new{ todo.call }.join
     end
   end
 
-  it "should clean up lspaces properly even if an exception is raised" do
-    LSpace.new(:baz => 1) do
-      begin
-        LSpace.new(:baz => 1) do
-          raise "OOPS"
-        end
-      rescue => e
-        LSpace[:baz].should == 1
-      end
+  describe "#hierarchy" do
+    it "should return [self] if there is no parent" do
+      @lspace.hierarchy.should == [@lspace]
+    end
+
+    it "should return the full list if there are parents" do
+      l1 = LSpace.new({}, @lspace)
+      l2 = LSpace.new({}, l1)
+
+      l2.hierarchy.should == [l2, l1, @lspace]
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,10 @@
 require_relative '../lib/lspace'
+require_relative '../lib/lspace/eventmachine'
+require 'pry-rescue/rspec'
+
 RSpec.configure do |c|
   c.around(:each) do |example|
-    LSpace.new do
+    LSpace.clean do
       example.run
     end
   end

metadata

@@ -1,16 +1,64 @@
 --- !ruby/object:Gem::Specification
 name: lspace
 version: !ruby/object:Gem::Version
-  version: 0.1.pre.1
-  prerelease: 4
+  version: '0.1'
+  prerelease: 
 platform: ruby
 authors:
 - Conrad Irwin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-22 00:00:00.000000000 Z
-dependencies: []
+date: 2012-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Provides the convenience of global variables, without the safety concerns.
 email: conrad.irwin@gmail.com
 executables: []
@@ -20,10 +68,14 @@ files:
 - LICENSE.MIT
 - README.md
 - lib/lspace.rb
+- lib/lspace/class_methods.rb
 - lib/lspace/core_ext.rb
 - lib/lspace/eventmachine.rb
 - lib/lspace/thread.rb
 - lspace.gemspec
+- spec/class_method_spec.rb
+- spec/core_ext_spec.rb
+- spec/eventmachine_spec.rb
 - spec/lspace_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/ConradIrwin/lspace
@@ -41,9 +93,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24