Merge pull request #26 from matrix-org/invite-room-state

Invite room state

lib/client.js

@@ -1927,8 +1927,10 @@ function doInitialSync(client, historyLen, includeArchived) {
                     data.rooms[i].state = [];
                 }
                 if (data.rooms[i].membership === "invite") {
-                    // create fake invite state event (v1 sucks)
-                    data.rooms[i].state.push({
+                    var inviteEvent = data.rooms[i].invite;
+                    if (!inviteEvent) {
+                        // fallback for servers which don't serve the invite key yet
+                        inviteEvent = {
                             event_id: "$fake_" + room.roomId,
                             content: {
                                 membership: "invite"
@@ -1937,7 +1939,9 @@ function doInitialSync(client, historyLen, includeArchived) {
                             user_id: data.rooms[i].inviter,
                             room_id: room.roomId,
                             type: "m.room.member"
-                    });
+                        };
+                    }
+                    data.rooms[i].state.push(inviteEvent);
                 }
 
                 _processRoomEvents(

lib/models/room.js

@@ -6,6 +6,7 @@ var EventEmitter = require("events").EventEmitter;
 
 var RoomState = require("./room-state");
 var RoomSummary = require("./room-summary");
+var MatrixEvent = require("./event").MatrixEvent;
 var utils = require("../utils");
 
 /**
@@ -231,6 +232,34 @@ Room.prototype.addEvents = function(events, duplicateStrategy) {
  * @fires module:client~MatrixClient#event:"Room.name"
  */
 Room.prototype.recalculate = function(userId) {
+    // set fake stripped state events if this is an invite room so logic remains
+    // consistent elsewhere.
+    var self = this;
+    var membershipEvent = this.currentState.getStateEvents(
+        "m.room.member", userId
+    );
+    if (membershipEvent && membershipEvent.getContent().membership === "invite") {
+        var strippedStateEvents = membershipEvent.event.invite_room_state || [];
+        utils.forEach(strippedStateEvents, function(strippedEvent) {
+            var existingEvent = self.currentState.getStateEvents(
+                strippedEvent.type, strippedEvent.state_key
+            );
+            if (!existingEvent) {
+                // set the fake stripped event instead
+                self.currentState.setStateEvents([new MatrixEvent({
+                    type: strippedEvent.type,
+                    state_key: strippedEvent.state_key,
+                    content: strippedEvent.content,
+                    event_id: "$fake" + Date.now(),
+                    room_id: self.roomId,
+                    user_id: userId // technically a lie
+                })]);
+            }
+        });
+    }
+
+
+
     var oldName = this.name;
     this.name = calculateRoomName(this, userId);
     this.summary = new RoomSummary(this.roomId, {

spec/unit/room.spec.js

@@ -338,7 +338,7 @@ describe("Room", function() {
         });
     });
 
-    describe("recalculate (Room Name)", function() {
+    describe("recalculate", function() {
         var stateLookup = {
             // event.type + "$" event.state_key : MatrixEvent
         };
@@ -405,6 +405,50 @@ describe("Room", function() {
             });
         });
 
+        describe("Room.recalculate => Stripped State Events", function() {
+            it("should set stripped state events as actual state events if the " +
+            "room is an invite room", function() {
+                var roomName = "flibble";
+
+                addMember(userA, "invite");
+                stateLookup["m.room.member$" + userA].event.invite_room_state = [
+                    {
+                        type: "m.room.name",
+                        state_key: "",
+                        content: {
+                            name: roomName
+                        }
+                    }
+                ];
+
+                room.recalculate(userA);
+                expect(room.currentState.setStateEvents).toHaveBeenCalled();
+                // first call, first arg (which is an array), first element in array
+                var fakeEvent = room.currentState.setStateEvents.calls[0].args[0][0];
+                expect(fakeEvent.getContent()).toEqual({
+                    name: roomName
+                });
+            });
+
+            it("should not clobber state events if it isn't an invite room", function() {
+                addMember(userA, "join");
+                stateLookup["m.room.member$" + userA].event.invite_room_state = [
+                    {
+                        type: "m.room.name",
+                        state_key: "",
+                        content: {
+                            name: "flibble"
+                        }
+                    }
+                ];
+
+                room.recalculate(userA);
+                expect(room.currentState.setStateEvents).not.toHaveBeenCalled();
+            });
+        });
+
+        describe("Room.recalculate => Room Name", function() {
+
             it("should return the names of members in a private (invite join_rules)" +
             " room if a room name and alias don't exist and there are >3 members.",
             function() {
@@ -549,6 +593,8 @@ describe("Room", function() {
                 var name = room.name;
                 expect(name).toEqual("?");
             });
+
+        });
     });
 
     describe("receipts", function() {