Add the new websocket package (which is just a helper for kataras/neffos) and an example for go server, client, browser client and nodejs client. Add a .fossa.yml and the generated NOTICE file for 3rd-party libs. Update go.mod, go.sum. Update the vendor folder for pongo2 to its latest master as well

Former-commit-id: 89c05079415977d65e7328a1eb8a1c602d76f78a

_examples/websocket/basic/browser/index.html

@@ -0,0 +1,93 @@
+<!-- the message's input -->
+<input id="input" type="text" />
+
+<!-- when clicked then a websocket event will be sent to the server, at this example we registered the 'chat' -->
+<button id="sendBtn" disabled>Send</button>
+
+<!-- the messages will be shown here -->
+<pre id="output"></pre>
+<!-- import the iris client-side library for browser from a CDN or locally.
+     However, `neffos.(min.)js` is a NPM package too so alternatively,
+     you can use it as dependency on your package.json and all nodejs-npm tooling become available:
+     see the "browserify" example for more-->
+<script src="https://cdn.jsdelivr.net/npm/neffos.js@0.1.8/dist/neffos.min.js"></script>
+<script>
+    // `neffos` global variable is available now.
+    var scheme = document.location.protocol == "https:" ? "wss" : "ws";
+    var port = document.location.port ? ":" + document.location.port : "";
+    var wsURL = scheme + "://" + document.location.hostname + port + "/echo";
+
+    var outputTxt = document.getElementById("output");
+    function addMessage(msg) {
+        outputTxt.innerHTML += msg + "\n";
+    }
+
+    function handleError(reason) {
+        console.log(reason);
+        window.alert(reason);
+    }
+
+    function handleNamespaceConnectedConn(nsConn) {
+        let inputTxt = document.getElementById("input");
+        let sendBtn = document.getElementById("sendBtn");
+
+        sendBtn.disabled = false;
+        sendBtn.onclick = function () {
+            const input = inputTxt.value;
+            inputTxt.value = "";
+            nsConn.emit("chat", input);
+            addMessage("Me: " + input);
+        };
+    }
+
+    async function runExample() {
+        // You can omit the "default" and simply define only Events, the namespace will be an empty string"",
+        // however if you decide to make any changes on this example make sure the changes are reflecting inside the ../server.go file as well.
+        try {
+            const conn = await neffos.dial(wsURL, {
+                default: { // "default" namespace.
+                    _OnNamespaceConnected: function (nsConn, msg) {
+                        addMessage("connected to namespace: " + msg.Namespace);
+                        handleNamespaceConnectedConn(nsConn)
+                    },
+                    _OnNamespaceDisconnect: function (nsConn, msg) {
+                        addMessage("disconnected from namespace: " + msg.Namespace);
+                    },
+                    chat: function (nsConn, msg) { // "chat" event.
+                        addMessage(msg.Body);
+                    }
+                }
+            });
+
+            // You can either wait to conenct or just conn.connect("connect")
+            // and put the `handleNamespaceConnectedConn` inside `_OnNamespaceConnected` callback instead.
+            // const nsConn = await conn.connect("default");
+            // handleNamespaceConnectedConn(nsConn);
+            conn.connect("default");
+
+        } catch (err) {
+            handleError(err);
+        }
+    }
+
+    runExample();
+
+    // If "await" and "async" are available, use them instead^, all modern browsers support those,
+    // all of the javascript examples will be written using async/await method instead of promise then/catch callbacks.
+    // A usage example of promise then/catch follows:
+    // neffos.dial(wsURL, {
+    //     default: { // "default" namespace.
+    //         _OnNamespaceConnected: function (ns, msg) {
+    //             addMessage("connected to namespace: " + msg.Namespace);
+    //         },
+    //         _OnNamespaceDisconnect: function (ns, msg) {
+    //             addMessage("disconnected from namespace: " + msg.Namespace);
+    //         },
+    //         chat: function (ns, msg) { // "chat" event.
+    //             addMessage(msg.Body);
+    //         }
+    //     }
+    // }).then(function (conn) {
+    //     conn.connect("default").then(handleNamespaceConnectedConn).catch(handleError);
+    // }).catch(handleError);
+</script>

_examples/websocket/basic/browserify/README.md

@@ -0,0 +1,11 @@
+# Browserify example
+
+```sh
+$ npm install --only=dev # install browserify from the devDependencies.
+$ npm run-script build # browserify and minify the `app.js` into `bundle.js`.
+$ cd ../ && go run server.go # start the neffos server.
+```
+
+> make sure that you have [golang](https://golang.org/dl) installed to run and edit the neffos (server-side).
+
+That's all, now navigate to <http://localhost:8080/browserify>.

_examples/websocket/basic/browserify/app.js

@@ -0,0 +1,61 @@
+const neffos = require('neffos.js');
+
+var scheme = document.location.protocol == "https:" ? "wss" : "ws";
+var port = document.location.port ? ":" + document.location.port : "";
+
+var wsURL = scheme + "://" + document.location.hostname + port + "/echo";
+
+var outputTxt = document.getElementById("output");
+function addMessage(msg) {
+  outputTxt.innerHTML += msg + "\n";
+}
+
+function handleError(reason) {
+  console.log(reason);
+  window.alert(reason);
+}
+
+function handleNamespaceConnectedConn(nsConn) {
+  const inputTxt = document.getElementById("input");
+  const sendBtn = document.getElementById("sendBtn");
+
+  sendBtn.disabled = false;
+  sendBtn.onclick = function () {
+    const input = inputTxt.value;
+    inputTxt.value = "";
+
+    nsConn.emit("chat", input);
+    addMessage("Me: " + input);
+  };
+}
+
+async function runExample() {
+  try {
+    const conn = await neffos.dial(wsURL, {
+      default: { // "default" namespace.
+        _OnNamespaceConnected: function (nsConn, msg) {
+          addMessage("connected to namespace: " + msg.Namespace);
+          handleNamespaceConnectedConn(nsConn);
+        },
+        _OnNamespaceDisconnect: function (nsConn, msg) {
+          addMessage("disconnected from namespace: " + msg.Namespace);
+        },
+        chat: function (nsConn, msg) { // "chat" event.
+          addMessage(msg.Body);
+        }
+      }
+    });
+
+    // You can either wait to conenct or just conn.connect("connect")
+    // and put the `handleNamespaceConnectedConn` inside `_OnNamespaceConnected` callback instead.
+    // const nsConn = await conn.connect("default");
+    // handleNamespaceConnectedConn(nsConn);
+    conn.connect("default");
+
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+runExample();
+

_examples/websocket/basic/browserify/index.html

@@ -0,0 +1,10 @@
+<!-- the message's input -->
+<input id="input" type="text" />
+
+<!-- when clicked then a websocket event will be sent to the server, at this example we registered the 'chat' -->
+<button id="sendBtn" disabled>Send</button>
+
+<!-- the messages will be shown here -->
+<pre id="output"></pre>
+
+<script src="./bundle.js"></script>

_examples/websocket/basic/browserify/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "neffos.js.example.browserify",
+    "version": "0.0.1",
+    "scripts": {
+        "browserify": "browserify ./app.js -o ./bundle.js",
+        "minifyES6": "minify ./bundle.js --outFile ./bundle.js",
+        "build": "npm run-script browserify && npm run-script minifyES6"
+    },
+    "dependencies": {
+        "neffos.js": "latest"
+    },
+    "devDependencies": {
+        "browserify": "^16.2.3",
+        "babel-minify": "^0.5.0"
+    }
+}

_examples/websocket/basic/go-client/client.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	"github.com/kataras/iris/websocket"
+)
+
+const (
+	endpoint              = "ws://localhost:8080/echo"
+	namespace             = "default"
+	dialAndConnectTimeout = 5 * time.Second
+)
+
+// this can be shared with the server.go's.
+// `NSConn.Conn` has the `IsClient() bool` method which can be used to
+// check if that's is a client or a server-side callback.
+var clientEvents = websocket.Namespaces{
+	namespace: websocket.Events{
+		websocket.OnNamespaceConnected: func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] connected to namespace [%s]", c, msg.Namespace)
+			return nil
+		},
+		websocket.OnNamespaceDisconnect: func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] disconnected from namespace [%s]", c, msg.Namespace)
+			return nil
+		},
+		"chat": func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] sent: %s", c.Conn.ID(), string(msg.Body))
+
+			// Write message back to the client message owner with:
+			// c.Emit("chat", msg)
+			// Write message to all except this client with:
+			c.Conn.Server().Broadcast(c, msg)
+			return nil
+		},
+	},
+}
+
+func main() {
+	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(dialAndConnectTimeout))
+	defer cancel()
+
+	client, err := websocket.Dial(ctx, websocket.GorillaDialer, endpoint, clientEvents)
+	if err != nil {
+		panic(err)
+	}
+	defer client.Close()
+
+	c, err := client.Connect(ctx, namespace)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Fprint(os.Stdout, ">> ")
+	scanner := bufio.NewScanner(os.Stdin)
+	for {
+		if !scanner.Scan() {
+			log.Printf("ERROR: %v", scanner.Err())
+			return
+		}
+
+		text := scanner.Bytes()
+
+		if bytes.Equal(text, []byte("exit")) {
+			if err := c.Disconnect(nil); err != nil {
+				log.Printf("reply from server: %v", err)
+			}
+			break
+		}
+
+		ok := c.Emit("chat", text)
+		if !ok {
+			break
+		}
+
+		fmt.Fprint(os.Stdout, ">> ")
+	}
+} // try running this program twice or/and run the server's http://localhost:8080 to check the browser client as well.

_examples/websocket/basic/server.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"log"
+
+	"github.com/kataras/iris"
+	"github.com/kataras/iris/websocket"
+)
+
+const namespace = "default"
+
+// if namespace is empty then simply websocket.Events{...} can be used instead.
+var serverEvents = websocket.Namespaces{
+	namespace: websocket.Events{
+		websocket.OnNamespaceConnected: func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] connected to namespace [%s]", c, msg.Namespace)
+			return nil
+		},
+		websocket.OnNamespaceDisconnect: func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] disconnected from namespace [%s]", c, msg.Namespace)
+			return nil
+		},
+		"chat": func(c *websocket.NSConn, msg websocket.Message) error {
+			log.Printf("[%s] sent: %s", c.Conn.ID(), string(msg.Body))
+
+			// Write message back to the client message owner with:
+			// c.Emit("chat", msg)
+			// Write message to all except this client with:
+			c.Conn.Server().Broadcast(c, msg)
+			return nil
+		},
+	},
+}
+
+func main() {
+	app := iris.New()
+	websocketServer := websocket.New(
+		websocket.DefaultGorillaUpgrader, /*DefaultGobwasUpgrader can be used as well*/
+		serverEvents)
+
+	// serves the endpoint of ws://localhost:8080/echo
+	app.Get("/echo", websocket.Handler(websocketServer))
+
+	// serves the browser-based websocket client.
+	app.Get("/", func(ctx iris.Context) {
+		ctx.ServeFile("./browser/index.html", false)
+	})
+
+	// serves the npm browser websocket client usage example.
+	app.StaticWeb("/browserify", "./browserify")
+
+	app.Run(iris.Addr(":8080"))
+}