3 files changed, 37 insertions, 7 deletions
diff --git a/Sluift/ElementConvertors/DiscoInfoConvertor.cpp b/Sluift/ElementConvertors/DiscoInfoConvertor.cpp
index 2aa4a77..a528211 100644
--- a/Sluift/ElementConvertors/DiscoInfoConvertor.cpp
+++ b/Sluift/ElementConvertors/DiscoInfoConvertor.cpp
@@ -1,119 +1,144 @@
 /*
  * Copyright (c) 2013-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/DiscoInfoConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
+#include <Swiften/Elements/Form.h>
+#include <Sluift/LuaElementConvertors.h>
 #include <Sluift/Lua/LuaUtils.h>
 
 using namespace Swift;
 
-DiscoInfoConvertor::DiscoInfoConvertor() : GenericLuaElementConvertor<DiscoInfo>("disco_info") {
+DiscoInfoConvertor::DiscoInfoConvertor(LuaElementConvertors* convertors) :
+        GenericLuaElementConvertor<DiscoInfo>("disco_info"),
+        convertors(convertors) {
 }
 
 DiscoInfoConvertor::~DiscoInfoConvertor() {
 }
 
 std::shared_ptr<DiscoInfo> DiscoInfoConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<DiscoInfo> result = std::make_shared<DiscoInfo>();
     if (boost::optional<std::string> value = Lua::getStringField(L, -1, "node")) {
         result->setNode(*value);
     }
 
     lua_getfield(L, -1, "identities");
     if (lua_istable(L, -1)) {
         for (lua_pushnil(L); lua_next(L, -2); ) {
             result->addIdentity(DiscoInfo::Identity(
                     Lua::getStringField(L, -1, "name").get_value_or(""),
                     Lua::getStringField(L, -1, "category").get_value_or("client"),
                     Lua::getStringField(L, -1, "type").get_value_or("pc"),
                     Lua::getStringField(L, -1, "language").get_value_or("")));
             lua_pop(L, 1);
         }
     }
     lua_pop(L, 1);
 
     lua_getfield(L, -1, "features");
     if (lua_istable(L, -1)) {
         for (lua_pushnil(L); lua_next(L, -2); ) {
             if (lua_isstring(L, -1)) {
                 result->addFeature(lua_tostring(L, -1));
             }
             lua_pop(L, 1);
         }
     }
     lua_pop(L, 1);
 
-    // TODO: Extension
+    lua_getfield(L, -1, "extensions");
+    if (lua_istable(L, -1)) {
+        for (lua_pushnil(L); lua_next(L, -2); ) {
+            std::shared_ptr<Form> form = std::dynamic_pointer_cast<Form>(convertors->convertFromLuaUntyped(L, -1, "form"));
+            if (!!form) {
+                result->addExtension(form);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
 
     return result;
 }
 
 void DiscoInfoConvertor::doConvertToLua(lua_State* L, std::shared_ptr<DiscoInfo> payload) {
     lua_newtable(L);
     if (!payload->getNode().empty()) {
         lua_pushstring(L, payload->getNode().c_str());
         lua_setfield(L, -2, "node");
     }
 
     const std::vector<DiscoInfo::Identity>& identities = payload->getIdentities();
     if (!identities.empty()) {
         lua_createtable(L, boost::numeric_cast<int>(identities.size()), 0);
         for (size_t i = 0; i < identities.size(); ++i) {
             lua_createtable(L, 0, 0);
             if (!identities[i].getName().empty()) {
                 lua_pushstring(L, identities[i].getName().c_str());
                 lua_setfield(L, -2, "name");
             }
             if (!identities[i].getCategory().empty()) {
                 lua_pushstring(L, identities[i].getCategory().c_str());
                 lua_setfield(L, -2, "category");
             }
             if (!identities[i].getType().empty()) {
                 lua_pushstring(L, identities[i].getType().c_str());
                 lua_setfield(L, -2, "type");
             }
             if (!identities[i].getLanguage().empty()) {
                 lua_pushstring(L, identities[i].getLanguage().c_str());
                 lua_setfield(L, -2, "language");
             }
             lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
         }
         lua_setfield(L, -2, "identities");
     }
 
     const std::vector<std::string>& features = payload->getFeatures();
     if (!features.empty()) {
         lua_createtable(L, boost::numeric_cast<int>(features.size()), 0);
         for (size_t i = 0; i < features.size(); ++i) {
             lua_pushstring(L, features[i].c_str());
             lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
         }
         lua_setfield(L, -2, "features");
     }
 
-    // TODO: Extension
+    const std::vector<Form::ref>& extensions = payload->getExtensions();
+    if (!extensions.empty()) {
+        lua_createtable(L, boost::numeric_cast<int>(extensions.size()), 0);
+        for (size_t i = 0; i < extensions.size(); ++i) {
+            if (convertors->convertToLuaUntyped(L, extensions[i]) > 0) {
+                lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
+            }
+        }
+        lua_setfield(L, -2, "extensions");
+    }
 }
 
 boost::optional<LuaElementConvertor::Documentation> DiscoInfoConvertor::getDocumentation() const {
     return Documentation(
             "DiscoInfo",
             "Represents `disco#info` service discovery data.\n\n"
             "This table has the following structure:\n\n"
             "- `node`: string\n"
             "- `identities`: array(table)\n"
             "  - `name`: string\n"
             "  - `category`: string\n"
             "  - `type`: string\n"
             "  - `language`: string\n"
             "- `features`: array(string)\n"
+            "- `extensions`: array(table)\n"
+            "-   `form`: string @{Form} (Optional)\n"
     );
 }
diff --git a/Sluift/ElementConvertors/DiscoInfoConvertor.h b/Sluift/ElementConvertors/DiscoInfoConvertor.h
index 34f8237..c1b2910 100644
--- a/Sluift/ElementConvertors/DiscoInfoConvertor.h
+++ b/Sluift/ElementConvertors/DiscoInfoConvertor.h
@@ -1,24 +1,29 @@
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <Swiften/Base/Override.h>
 #include <Swiften/Elements/DiscoInfo.h>
 
 #include <Sluift/GenericLuaElementConvertor.h>
 
 namespace Swift {
+    class LuaElementConvertors;
+
     class DiscoInfoConvertor : public GenericLuaElementConvertor<DiscoInfo> {
         public:
-            DiscoInfoConvertor();
+            DiscoInfoConvertor(LuaElementConvertors* convertors);
             virtual ~DiscoInfoConvertor();
 
             virtual std::shared_ptr<DiscoInfo> doConvertFromLua(lua_State*) SWIFTEN_OVERRIDE;
             virtual void doConvertToLua(lua_State*, std::shared_ptr<DiscoInfo>) SWIFTEN_OVERRIDE;
             virtual boost::optional<Documentation> getDocumentation() const SWIFTEN_OVERRIDE;
+
+        private:
+            LuaElementConvertors* convertors;
     };
 }
diff --git a/Sluift/LuaElementConvertors.cpp b/Sluift/LuaElementConvertors.cpp
index aac4d93..db91761 100644
--- a/Sluift/LuaElementConvertors.cpp
+++ b/Sluift/LuaElementConvertors.cpp
@@ -1,86 +1,86 @@
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/LuaElementConvertors.h>
 
 #include <memory>
 
 #include <Sluift/ElementConvertors/BodyConvertor.h>
 #include <Sluift/ElementConvertors/CarbonsReceivedConvertor.h>
 #include <Sluift/ElementConvertors/CarbonsSentConvertor.h>
 #include <Sluift/ElementConvertors/CommandConvertor.h>
 #include <Sluift/ElementConvertors/DOMElementConvertor.h>
 #include <Sluift/ElementConvertors/DefaultElementConvertor.h>
 #include <Sluift/ElementConvertors/DelayConvertor.h>
 #include <Sluift/ElementConvertors/DiscoInfoConvertor.h>
 #include <Sluift/ElementConvertors/DiscoItemsConvertor.h>
 #include <Sluift/ElementConvertors/FormConvertor.h>
 #include <Sluift/ElementConvertors/ForwardedConvertor.h>
 #include <Sluift/ElementConvertors/IQConvertor.h>
 #include <Sluift/ElementConvertors/MAMFinConvertor.h>
 #include <Sluift/ElementConvertors/MAMQueryConvertor.h>
 #include <Sluift/ElementConvertors/MAMResultConvertor.h>
 #include <Sluift/ElementConvertors/MessageConvertor.h>
 #include <Sluift/ElementConvertors/PresenceConvertor.h>
 #include <Sluift/ElementConvertors/PubSubEventConvertor.h>
 #include <Sluift/ElementConvertors/RawXMLElementConvertor.h>
 #include <Sluift/ElementConvertors/ResultSetConvertor.h>
 #include <Sluift/ElementConvertors/SoftwareVersionConvertor.h>
 #include <Sluift/ElementConvertors/StatusConvertor.h>
 #include <Sluift/ElementConvertors/StatusShowConvertor.h>
 #include <Sluift/ElementConvertors/SubjectConvertor.h>
 #include <Sluift/ElementConvertors/VCardConvertor.h>
 #include <Sluift/ElementConvertors/VCardUpdateConvertor.h>
 #include <Sluift/Lua/Exception.h>
 #include <Sluift/Lua/LuaUtils.h>
 #include <Sluift/LuaElementConvertor.h>
 
 using namespace Swift;
 
 LuaElementConvertors::LuaElementConvertors() {
     registerConvertors();
     convertors.push_back(std::make_shared<StatusConvertor>());
     convertors.push_back(std::make_shared<StatusShowConvertor>());
     convertors.push_back(std::make_shared<DelayConvertor>());
     convertors.push_back(std::make_shared<CommandConvertor>(this));
     convertors.push_back(std::make_shared<PubSubEventConvertor>(this));
     convertors.push_back(std::make_shared<BodyConvertor>());
     convertors.push_back(std::make_shared<SubjectConvertor>());
     convertors.push_back(std::make_shared<VCardConvertor>());
     convertors.push_back(std::make_shared<VCardUpdateConvertor>());
     convertors.push_back(std::make_shared<FormConvertor>());
     convertors.push_back(std::make_shared<SoftwareVersionConvertor>());
-    convertors.push_back(std::make_shared<DiscoInfoConvertor>());
+    convertors.push_back(std::make_shared<DiscoInfoConvertor>(this));
     convertors.push_back(std::make_shared<DiscoItemsConvertor>());
     convertors.push_back(std::make_shared<IQConvertor>(this));
     convertors.push_back(std::make_shared<PresenceConvertor>(this));
     convertors.push_back(std::make_shared<MessageConvertor>(this));
     convertors.push_back(std::make_shared<ResultSetConvertor>());
     convertors.push_back(std::make_shared<ForwardedConvertor>(this));
     convertors.push_back(std::make_shared<MAMResultConvertor>(this));
     convertors.push_back(std::make_shared<MAMQueryConvertor>(this));
     convertors.push_back(std::make_shared<MAMFinConvertor>(this));
     convertors.push_back(std::make_shared<CarbonsReceivedConvertor>(this));
     convertors.push_back(std::make_shared<CarbonsSentConvertor>(this));
     convertors.push_back(std::make_shared<DOMElementConvertor>());
     convertors.push_back(std::make_shared<RawXMLElementConvertor>());
     convertors.push_back(std::make_shared<DefaultElementConvertor>());
 }
 
 LuaElementConvertors::~LuaElementConvertors() {
 }
 
 #include <Sluift/ElementConvertors/ElementConvertors.ipp>
 
 std::shared_ptr<Element> LuaElementConvertors::convertFromLua(lua_State* L, int index) {
     if (lua_isstring(L, index)) {
         return convertFromLuaUntyped(L, index, "xml");
     }
     else if (lua_istable(L, index)) {
         lua_getfield(L, index, "_type");
         if (lua_isstring(L, -1)) {
             std::string type = lua_tostring(L, -1);
             lua_pop(L, 1);