Changeset 700

Timestamp:

06/16/08 05:05:44 (4 months ago)

Author:

raggi

Message:

• Merge forward trunk into branches/raggi
  

Files:

• branches/raggi/docs/ChangeLog (modified) (1 diff)
• branches/raggi/lib/eventmachine.rb (modified) (1 diff)
• branches/raggi/tests/test_next_tick.rb (modified) (1 diff)

branches/raggi/docs/ChangeLog

@@ -117 +117 @@
-15May08: Supported EM#get_sockname for acceptors (TCP server sockets).
-        Requested by Roger Pack.
+15Jun08: Supported nested calls to EM#run. Many people contributed ideas to 
+        this, notable raggi and tmm1.

branches/raggi/lib/eventmachine.rb

@@ -214 +214 @@
-        # a C++ runtime error.
-        #
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                end
-        end

branches/raggi/tests/test_next_tick.rb

@@ -56 +56 @@
-                assert true
-        end
+
+        # This illustrates the solution to a long-standing problem.
+        # It's now possible to correctly nest calls to EM#run.
+        # See the source code commentary for EM#run for more info.
+        #
+        def test_run_run
+                EM.run {
+                        EM.run {
+                                EM.next_tick {EM.stop}
+                        }
+                }
+        end
+
+        # We now support an additional parameter for EM#run.
+        # You can pass two procs to EM#run now. The first is executed as the normal
+        # run block. The second (if given) is scheduled for execution after the
+        # reactor loop completes.
+        # The reason for supporting this is subtle. There has always been an expectation
+        # that EM#run doesn't return until after the reactor loop ends. But now it's
+        # possible to nest calls to EM#run, which means that a nested call WILL
+        # RETURN. In order to write code that will run correctly either way, it's
+        # recommended to put any code which must execute after the reactor completes
+        # in the second parameter.
+        #
+        def test_run_run_2
+                a = proc {EM.stop}
+                b = proc {assert true}
+                EM.run a, b
+        end
+
+
+        # This illustrates that EM#run returns when it's called nested.
+        # This isn't a feature, rather it's something to be wary of when writing code
+        # that must run correctly even if EM#run is called while a reactor is already
+        # running.
+        def test_run_run_3
+                a = []
+                EM.run {
+                        EM.run proc {EM.stop}, proc {a << 2}
+                        a << 1
+                }
+                assert_equal( [1,2], a )
+        end
+
-end