Fix broken doc link, move GH ztellman refs to clj-commons

Author: KingMob

README.md

@@ -4,15 +4,15 @@
 
 ![](docs/aleph.png)
 
-Aleph exposes data from the network as a [Manifold](https://github.com/ztellman/manifold) stream, which can easily be transformed into a `java.io.InputStream`, [core.async](https://github.com/clojure/core.async) channel, Clojure sequence, or [many other byte representations](https://github.com/ztellman/byte-streams).  It exposes simple default wrappers for HTTP, TCP, and UDP, but allows access to full performance and flexibility of the underlying [Netty](https://github.com/netty/netty) library.
+Aleph exposes data from the network as a [Manifold](https://github.com/clj-commons/manifold) stream, which can easily be transformed into a `java.io.InputStream`, [core.async](https://github.com/clojure/core.async) channel, Clojure sequence, or [many other byte representations](https://github.com/clj-commons/byte-streams).  It exposes simple default wrappers for HTTP, TCP, and UDP, but allows access to full performance and flexibility of the underlying [Netty](https://github.com/netty/netty) library.
 
 ```clj
 [aleph "0.4.6"]
 ```
 
 ### HTTP
 
-Aleph follows the [Ring](https://github.com/ring-clojure) spec fully, and can be a drop-in replacement for any existing Ring-compliant server.  However, it also allows for the handler function to return a [Manifold deferred](https://github.com/ztellman/manifold) to represent an eventual response.  This feature may not play nicely with synchronous Ring middleware which modifies the response, but this can be easily fixed by reimplementing the middleware using Manifold's [let-flow](https://github.com/ztellman/manifold/blob/master/docs/deferred.md#let-flow) operator. `aleph.http/wrap-ring-async-handler` helper can be used to covert async 3-arity Ring handler to Aleph-compliant one.
+Aleph follows the [Ring](https://github.com/ring-clojure) spec fully, and can be a drop-in replacement for any existing Ring-compliant server.  However, it also allows for the handler function to return a [Manifold deferred](https://github.com/clj-commons/manifold) to represent an eventual response.  This feature may not play nicely with synchronous Ring middleware which modifies the response, but this can be easily fixed by reimplementing the middleware using Manifold's [let-flow](https://github.com/clj-commons/manifold/blob/master/doc/deferred.md#let-flow) operator. `aleph.http/wrap-ring-async-handler` helper can be used to covert async 3-arity Ring handler to Aleph-compliant one.
 
 ```clj
 (require '[aleph.http :as http])
@@ -49,21 +49,21 @@ Aleph attempts to mimic the clj-http API and capabilities fully. It supports mul
 
 * proxy configuration should be set for the connection when seting up a connection pool, per-request proxy setups are not allowed
 
-* HTTP proxy functionality is extended with tunneling settings, optional HTTP headers and connection timeout control, see [all configuration keys](https://github.com/ztellman/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http.clj#L122-L132)
+* HTTP proxy functionality is extended with tunneling settings, optional HTTP headers and connection timeout control, see [all configuration keys](https://github.com/clj-commons/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http.clj#L122-L132)
 
 * `:proxy-ignore-hosts` is not supported
 
-* both cookies middleware and built-in cookies storages do not support cookie params obsoleted since RFC2965: comment, comment URL, discard, version (see the full structure of the [cookie](https://github.com/ztellman/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http/client_middleware.clj#L645-L655))
+* both cookies middleware and built-in cookies storages do not support cookie params obsoleted since RFC2965: comment, comment URL, discard, version (see the full structure of the [cookie](https://github.com/clj-commons/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http/client_middleware.clj#L645-L655))
 
 * when using `:debug`, `:save-request?` and `:debug-body?` options, corresponding requests would be stored in `:aleph/netty-request`, `:aleph/request`, `:aleph/request-body` keys of the response map
 
 * `:response-interceptor` option is not supported
 
-* Aleph introduces `:log-activity` connection pool [configuration](https://github.com/ztellman/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http.clj#L120) to switch on the logging of the connections status changes as well as requests/response hex dumps
+* Aleph introduces `:log-activity` connection pool [configuration](https://github.com/clj-commons/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/http.clj#L120) to switch on the logging of the connections status changes as well as requests/response hex dumps
 
 * `:cache` and `:cache-config` options are not supported as for now
 
-Aleph client also supports fully async and [highly customizable](https://github.com/ztellman/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/netty.clj#L783-L796) DNS resolver.
+Aleph client also supports fully async and [highly customizable](https://github.com/clj-commons/aleph/blob/d33c76d6c7d1bf9788369fe6fd9d0e56434c8244/src/aleph/netty.clj#L783-L796) DNS resolver.
 
 To learn more, [read the example code](http://aleph.io/examples/literate.html#aleph.examples.http).
 
@@ -87,7 +87,7 @@ To learn more, [read the example code](http://aleph.io/examples/literate.html#al
 
 ### TCP
 
-A TCP server is similar to an HTTP server, except that for each connection the handler takes two arguments: a duplex stream and a map containing information about the client.  The stream will emit byte-arrays, which can be coerced into other byte representations using the [byte-streams](https://github.com/ztellman/byte-streams) library.  The stream will accept any messages which can be coerced into a binary representation.
+A TCP server is similar to an HTTP server, except that for each connection the handler takes two arguments: a duplex stream and a map containing information about the client.  The stream will emit byte-arrays, which can be coerced into other byte representations using the [byte-streams](https://github.com/clj-commons/byte-streams) library.  The stream will accept any messages which can be coerced into a binary representation.
 
 An echo TCP server is very similar to the above WebSocket example:
 

examples/src/aleph/examples/http.clj

@@ -17,7 +17,7 @@
 ;; [Ring spec](https://github.com/ring-clojure/ring/blob/master/SPEC), which means it can be
 ;; used as a drop-in replacement for pretty much any other Clojure webserver.  In order to
 ;; allow for asynchronous responses, however, it allows for the use of
-;; [Manifold](https://github.com/ztellman/manifold) deferreds and streams.  Uses of both
+;; [Manifold](https://github.com/clj-commons/manifold) deferreds and streams.  Uses of both
 ;; will be illustrated below.
 
 ;; Complete documentation for the `aleph.http` namespace can be found [here](http://aleph.io/codox/aleph/aleph.http.html).

examples/src/aleph/examples/tcp.clj

@@ -11,7 +11,7 @@
 
 ;; ## the basics
 
-;; This uses [Gloss](https://github.com/ztellman/gloss), which is a library for defining byte
+;; This uses [Gloss](https://github.com/clj-commons/gloss), which is a library for defining byte
 ;; formats, which are automatically compiled into encoder and streaming decoders.
 ;;
 ;; Here, we define a simple protocol where each frame starts with a 32-bit integer describing

src/aleph/flow.clj

@@ -26,7 +26,7 @@
      TimeUnit]))
 
 (defn instrumented-pool
-  "Returns a [Dirigiste](https://github.com/ztellman/dirigiste) object pool, which can be interacted
+  "Returns a [Dirigiste](https://github.com/clj-commons/dirigiste) object pool, which can be interacted
    with via `acquire`, `release`, and `dispose`.
 
    |:---|:----

src/aleph/http.clj

@@ -413,7 +413,7 @@
    | `pool` | the `connection-pool` that should be used, defaults to the `default-connection-pool`
    | `middleware` | any additional middleware that should be used for handling requests and responses
    | `headers` | the HTTP headers for the request
-   | `body` | an optional body, which should be coercable to a byte representation via [byte-streams](https://github.com/ztellman/byte-streams)
+   | `body` | an optional body, which should be coercable to a byte representation via [byte-streams](https://github.com/clj-commons/byte-streams)
    | `multipart` | a vector of bodies")
        :arglists arglists)))
 

src/aleph/http/server.clj

@@ -774,7 +774,7 @@
               ;; WebSocketServerCompressionHandler is stateful and requires
               ;; HTTP request to be send through the pipeline
               ;; See more:
-              ;; * https://github.com/ztellman/aleph/issues/494
+              ;; * https://github.com/clj-commons/aleph/issues/494
               ;; * https://github.com/netty/netty/pull/8973
               (let [compression-handler (WebSocketServerCompressionHandler.)
                     ctx (.context pipeline "websocket-frame-aggregator")]

src/aleph/netty.clj

@@ -212,7 +212,7 @@
             ;; workaround for the issue with executing RT.readString
             ;; on a Netty thread that doesn't have appropriate class loader
             ;; more information here:
-            ;; https://github.com/ztellman/aleph/issues/365
+            ;; https://github.com/clj-commons/aleph/issues/365
             class-loader (or (clojure.lang.RT/baseLoader)
                              (clojure.lang.RT/makeClassLoader))]
         (.addListener f