From 259f98d3cdc7274007c7ad4781979cc108b667f2 Mon Sep 17 00:00:00 2001
From: Miguel Grinberg <miguelgrinberg50@gmail.com>
Date: Sun, 17 Jan 2016 12:27:54 -0800
Subject: [PATCH] Expand tuples to multiple arguments, but not lists

---
 docs/index.rst       | 19 +++++++++++--------
 socketio/server.py   | 11 ++++++++---
 tests/test_server.py | 16 +++++++++++++++-
 3 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/docs/index.rst b/docs/index.rst
index 3edcd4e..472d0ee 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -99,10 +99,10 @@ environment dictionary. The server can inspect authentication or other headers
 to decide if the client is allowed to connect. To reject a client the handler
 must return ``False``.
 
-When the client sends an event to the server the appropriate event handler is
-invoked with the ``sid`` and the message. The application can define as many
-events as needed and associate them with event handlers. An event is defined
-simply by a name.
+When the client sends an event to the server, the appropriate event handler is
+invoked with the ``sid`` and the message, which can be a single or multiple
+arguments. The application can define as many events as needed and associate
+them with event handlers. An event is defined simply by a name.
 
 When a connection with a client is broken, the ``disconnect`` event is called,
 allowing the application to perform cleanup.
@@ -136,10 +136,13 @@ that it will lose the ability to address individual clients.
         sio.leave_room(sid, data['room'])
 
 The :func:`socketio.Server.emit` method takes an event name, a message payload
-of type ``str``, ``bytes``, ``list`` or ``dict``, and the recipient room. To
-address an individual client, the ``sid`` of that client should be given as
-room (assuming the application did not alter these initial rooms). To address
-all connected clients, the ``room`` argument should be omitted.
+of type ``str``, ``bytes``, ``list``, ``dict`` or ``tuple``, and the recipient
+room. When sending a ``tuple``, the elements in it need to be of any of the
+other four allowed types. The elements of the tuple will be passed as multiple
+arguments to the client-side callback function. To address an individual
+client, the ``sid`` of that client should be given as room (assuming the
+application did not alter these initial rooms). To address all connected
+clients, the ``room`` argument should be omitted.
 
 ::
 
diff --git a/socketio/server.py b/socketio/server.py
index f54ec80..ace4a5d 100644
--- a/socketio/server.py
+++ b/socketio/server.py
@@ -311,8 +311,14 @@ class Server(object):
             binary = False  # pragma: nocover
         else:
             binary = None
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        else:
+            data = [data]
         self._send_packet(sid, packet.Packet(packet.EVENT, namespace=namespace,
-                                             data=[event, data], id=id,
+                                             data=[event] + data, id=id,
                                              binary=binary))
 
     def _send_packet(self, sid, pkt):
@@ -365,10 +371,9 @@ class Server(object):
         r = self._trigger_event(data[0], namespace, sid, *data[1:])
         if id is not None:
             # send ACK packet with the response returned by the handler
+            # tuples are expanded as multiple arguments
             if isinstance(r, tuple):
                 data = list(r)
-            elif isinstance(r, list):
-                data = r
             else:
                 data = [r]
             if six.PY2 and not self.binary:
diff --git a/tests/test_server.py b/tests/test_server.py
index 6f2c7ca..470e27a 100644
--- a/tests/test_server.py
+++ b/tests/test_server.py
@@ -125,6 +125,20 @@ class TestServer(unittest.TestCase):
                                            '2/foo,["my event","my data"]',
                                            binary=False)
 
+    def test_emit_internal_with_tuple(self, eio):
+        s = server.Server()
+        s._emit_internal('123', 'my event', ('foo', 'bar'), namespace='/foo')
+        s.eio.send.assert_called_once_with('123',
+                                           '2/foo,["my event","foo","bar"]',
+                                           binary=False)
+
+    def test_emit_internal_with_list(self, eio):
+        s = server.Server()
+        s._emit_internal('123', 'my event', ['foo', 'bar'], namespace='/foo')
+        s.eio.send.assert_called_once_with('123',
+                                           '2/foo,["my event",["foo","bar"]]',
+                                           binary=False)
+
     def test_emit_internal_with_callback(self, eio):
         s = server.Server()
         id = s.manager._generate_ack_id('123', '/foo', 'cb')
@@ -304,7 +318,7 @@ class TestServer(unittest.TestCase):
         s.on('my message', handler)
         s._handle_eio_message('123', '21000["my message","a","b","c"]')
         handler.assert_called_once_with('123', 'a', 'b', 'c')
-        s.eio.send.assert_called_once_with('123', '31000[1,"2",true]',
+        s.eio.send.assert_called_once_with('123', '31000[[1,"2",true]]',
                                            binary=False)
 
     def test_handle_event_with_ack_binary(self, eio):