Fix spelling error

Author: eeng

README.md

@@ -1,6 +1,6 @@
 # Mercurius
 
-This project is a toy application developed with the purpose of exploring [Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html) concepts in the context of functional programming languages, specifically Clojure.
+This project is a toy application developed with the purpose of exploring [Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html) concepts in the context of functional programming languages, specifically [Clojure](https://clojure.org/).
 
 [![Build Status](https://travis-ci.org/eeng/mercurius.svg?branch=master)](https://travis-ci.org/eeng/mercurius)
 
@@ -16,35 +16,32 @@ As it was previously mentioned, Clean Architecture principles were applied to st
 
 ### Entities
 
-The core of the architecture contains the domain **entities** (wallets, orders, trades, etc.) that, being Clojure a functional language, consists of a set data structures and pure functions implementing the business logic. No side-effects are allowed in this layer, so its extremely easy to test.
-
-You may find the code for this layer in the `mercurius.*.domain.entities` namespaces.
+The core of the architecture contains the domain **entities** (wallets, orders, trades, etc.) that, being Clojure a functional language, consists of a set data structures and pure functions implementing the business logic. No side-effects nor dependencies on any framework are allowed in this layer, so its extremely easy to test.
 
 ### Use Cases
 
-Surrounding the entities we have the **use cases** layer. They will be in charge of coordinating all the steps required to fulfill the use case, e.g. fetching an entity from the database, calling the business logic, persisting the changes, and publishing the events. This layer does have side-effects, however, everything is done through protocols, and concrete implementations are injected from the outer layer, so it doesn't depend on any specific database or framework.
+Surrounding the entities we have the **use cases** layer. They will be in charge of coordinating all the steps required to fulfill the use case, e.g. fetching an entity from the database, calling the business logic, persisting the changes, and publishing the events. This layer does have side-effects, however, everything is done through protocols, and concrete implementations are injected from outer layers, so it doesn't depend on any specific database or framework.
 
 All use cases will be in the form of a high-order _builder_ function, i.e., a function that receives its dependencies and returns another function that finally executes the logic. This pattern allows us to treat all use cases uniformly, so we can apply cross-cutting concerns (like logging or transaction management) without repeating the same code everywhere. This is done in the _mediator_, which is the entry point to the domain.
 
-The code for this layer is the `mercurius.*.domain.use-cases.*` namespaces.
-
 ### Adapters
 
 Moving up, we have the interface adapters. Here there are repository implementations, controllers, and background processes. Regarding the repositories, simple in-memory implementations are provided (making use of the excellent Clojure STM), although, because the use cases depend exclusively on protocols, it should be fairly simple to swap them with real database implementations.
 
-Also in this layer, there is a core.async implementation of an event bus that it's used to broadcast the domain events.
+### Infrastructure
 
-The code is in the `mercurius.*.adapters.(repositories|controllers|processes).*` namespaces.
+In the outer layer we have the _details_ (as Uncle Bob likes to call them): The web server, the real-time communication framework, and a basic [core.async](https://github.com/clojure/core.async) implementation of a PubSub that it's used by the background processes to notify users when certain events occurred. It's based on protocols as well, so we can swap it by a Redis implementation, for example.
 
-### Infrastructure
+### Configuration
+
+This is the place where the entire backend is assembled. All the components are built and wired together with [Integrant](https://github.com/weavejester/integrant). This allows us to start/stop the whole system from the REPL.
 
 ## Implementation
 
 The system consists of a backend written in [Clojure](https://clojure.org/) and a frontend SPA built with [ClojureScript](https://clojurescript.org/). In addition, the following libraries assisted in the project:
 
 - [Integrant](https://github.com/weavejester/integrant) was used to wire all the component's dependencies and manage the stateful resources.
-- [core.async] TODO PubSub EventBus
-- [Sente](https://github.com/ptaoussanis/sente) provides realtime communication between frontend and backend through Web Sockets.
+- [Sente](https://github.com/ptaoussanis/sente) provides real-time communication between frontend and backend through Web Sockets.
 - [Reagent](https://reagent-project.github.io/) was used to build the user interface.
 - [re-frame](https://github.com/day8/re-frame/) cleanly separated the views from the state and event management in the frontend.
 - [shadow-cljs](http://shadow-cljs.org/) simplified the process of compiling ClojureScript.

dev/fiddles/pub_sub.clj

@@ -1,6 +1,6 @@
 (ns fiddles.pub-sub
   (:require [user :refer [system]]
-            [mercurius.core.infraestructure.messaging.channel-based-pub-sub :refer [start-channel-based-pub-sub stop-channel-based-pub-sub]]
+            [mercurius.core.infrastructure.messaging.channel-based-pub-sub :refer [start-channel-based-pub-sub stop-channel-based-pub-sub]]
             [mercurius.core.adapters.messaging.pub-sub :refer [publish subscribe unsubscribe]]))
 
 (comment
@@ -11,5 +11,5 @@
   (unsubscribe bus subscription)
   (stop-channel-based-pub-sub bus)
 
-  (let [bus (:infraestructure/pub-sub system)]
+  (let [bus (:infrastructure/pub-sub system)]
     (publish bus "push.ticker-updated.BTCUSD" {:ticker "BTCUSD" :last-price 10 :volume 90})))

src/mercurius/core/configuration/system.clj

@@ -8,12 +8,12 @@
             [mercurius.core.domain.use-cases.mediator.middleware.stm :refer [stm]]
             [mercurius.core.domain.messaging.event-bus :refer [emit]]
             [mercurius.core.adapters.messaging.pub-sub-event-bus :refer [new-pub-sub-event-bus]]
-            [mercurius.core.infraestructure.messaging.channel-based-pub-sub :refer [start-channel-based-pub-sub stop-channel-based-pub-sub]]
+            [mercurius.core.infrastructure.messaging.channel-based-pub-sub :refer [start-channel-based-pub-sub stop-channel-based-pub-sub]]
             [mercurius.core.adapters.processes.activity-logger :refer [new-activity-logger]]
             [mercurius.core.adapters.controllers.use-case-controller :refer [new-use-case-controller]]
             [mercurius.core.adapters.controllers.event-notifier :refer [start-event-notifier]]
-            [mercurius.core.infraestructure.web.server :refer [start-web-server stop-web-server]]
-            [mercurius.core.infraestructure.web.sente :refer [start-sente stop-sente]]
+            [mercurius.core.infrastructure.web.server :refer [start-web-server stop-web-server]]
+            [mercurius.core.infrastructure.web.sente :refer [start-sente stop-sente]]
             [mercurius.accounts.domain.use-cases.authenticate :refer [new-authenticate-use-case]]
             [mercurius.accounts.adapters.repositories.in-memory-user-repository :refer [new-in-memory-user-repo]]
             [mercurius.wallets.adapters.repositories.in-memory-wallet-repository :refer [new-in-memory-wallet-repo]]
@@ -85,26 +85,26 @@
    :adapters/ticker-repo nil
    :adapters/trade-repo nil
    :adapters/user-repo nil
-   :adapters/event-bus {:pub-sub (ig/ref :infraestructure/pub-sub)}
+   :adapters/event-bus {:pub-sub (ig/ref :infrastructure/pub-sub)}
    :processes/trade-finder {:event-bus (ig/ref :adapters/event-bus)
                             :dispatch (ig/ref :use-cases/dispatch)}
    :processes/trade-processor {:event-bus (ig/ref :adapters/event-bus)
                                :dispatch (ig/ref :use-cases/dispatch)}
    :processes/activity-logger {:event-bus (ig/ref :adapters/event-bus)}
    :processes/simulator {:dispatch (ig/ref :use-cases/dispatch)
-                         :pub-sub (ig/ref :infraestructure/pub-sub)}
+                         :pub-sub (ig/ref :infrastructure/pub-sub)}
    :controllers/use-case-controller {:dispatch (ig/ref :use-cases/dispatch)}
    :controllers/simulation-controller {:simulator (ig/ref :processes/simulator)}
    :controllers/event-notifier {:event-bus (ig/ref :adapters/event-bus)
-                                :pub-sub (ig/ref :infraestructure/pub-sub)}
-   :infraestructure/pub-sub nil
-   :infraestructure/web-server {:port port
-                                :session-key session-key
-                                :sente (ig/ref :infraestructure/sente)
-                                :dispatch (ig/ref :use-cases/dispatch)}
-   :infraestructure/sente {:use-case-controller (ig/ref :controllers/use-case-controller)
-                           :simulation-controller (ig/ref :controllers/simulation-controller)
-                           :pub-sub (ig/ref :infraestructure/pub-sub)}})
+                                :pub-sub (ig/ref :infrastructure/pub-sub)}
+   :infrastructure/pub-sub nil
+   :infrastructure/web-server {:port port
+                               :session-key session-key
+                               :sente (ig/ref :infrastructure/sente)
+                               :dispatch (ig/ref :use-cases/dispatch)}
+   :infrastructure/sente {:use-case-controller (ig/ref :controllers/use-case-controller)
+                          :simulation-controller (ig/ref :controllers/simulation-controller)
+                          :pub-sub (ig/ref :infrastructure/pub-sub)}})
 
 (defmethod ig/init-key :adapters/wallet-repo [_ _]
   (new-in-memory-wallet-repo))
@@ -121,10 +121,10 @@
 (defmethod ig/init-key :adapters/user-repo [_ _]
   (new-in-memory-user-repo))
 
-(defmethod ig/init-key :infraestructure/pub-sub [_ _]
+(defmethod ig/init-key :infrastructure/pub-sub [_ _]
   (start-channel-based-pub-sub))
 
-(defmethod ig/halt-key! :infraestructure/pub-sub [_ pub-sub]
+(defmethod ig/halt-key! :infrastructure/pub-sub [_ pub-sub]
   (stop-channel-based-pub-sub pub-sub))
 
 (defmethod ig/init-key :adapters/event-bus [_ deps]
@@ -209,10 +209,10 @@
 (defmethod ig/halt-key! :processes/simulator [_ simulator]
   (stop-simulator simulator))
 
-(defmethod ig/init-key :infraestructure/web-server [_ deps]
+(defmethod ig/init-key :infrastructure/web-server [_ deps]
   (start-web-server deps))
 
-(defmethod ig/halt-key! :infraestructure/web-server [_ server]
+(defmethod ig/halt-key! :infrastructure/web-server [_ server]
   (stop-web-server server))
 
 (defmethod ig/init-key :controllers/use-case-controller [_ deps]
@@ -224,10 +224,10 @@
 (defmethod ig/init-key :controllers/event-notifier [_ deps]
   (start-event-notifier deps))
 
-(defmethod ig/init-key :infraestructure/sente [_ deps]
+(defmethod ig/init-key :infrastructure/sente [_ deps]
   (start-sente deps))
 
-(defmethod ig/halt-key! :infraestructure/sente [_ sente]
+(defmethod ig/halt-key! :infrastructure/sente [_ sente]
   (stop-sente sente))
 
 (defn start

src/mercurius/core/infraestructure/messaging/channel_based_pub_sub.clj renamed to src/mercurius/core/infrastructure/messaging/channel_based_pub_sub.clj

@@ -1,4 +1,4 @@
-(ns mercurius.core.infraestructure.messaging.channel-based-pub-sub
+(ns mercurius.core.infrastructure.messaging.channel-based-pub-sub
   (:require [clojure.core.async :refer [put! chan close! go-loop <! sliding-buffer]]
             [clojure.string :as str]
             [taoensso.timbre :as log]

src/mercurius/core/infraestructure/web/handler.clj renamed to src/mercurius/core/infrastructure/web/handler.clj

@@ -1,4 +1,4 @@
-(ns mercurius.core.infraestructure.web.handler
+(ns mercurius.core.infrastructure.web.handler
   (:require [reitit.ring :as ring]
             [ring.middleware.keyword-params :refer [wrap-keyword-params]]
             [ring.middleware.params :refer [wrap-params]]
@@ -7,7 +7,7 @@
             [ring.middleware.session.cookie :refer [cookie-store]]
             [reitit.ring.middleware.muuntaja :as muuntaja]
             [muuntaja.core :as m]
-            [mercurius.core.infraestructure.web.index :refer [index]]
+            [mercurius.core.infrastructure.web.index :refer [index]]
             [mercurius.accounts.adapters.controllers.auth-controller :as auth]))
 
 (defn router [{{:keys [ring-ajax-get-or-ws-handshake ring-ajax-post]} :sente

src/mercurius/core/infraestructure/web/index.clj renamed to src/mercurius/core/infrastructure/web/index.clj

@@ -1,4 +1,4 @@
-(ns mercurius.core.infraestructure.web.index
+(ns mercurius.core.infrastructure.web.index
   (:require [hiccup.page :as page]
             [mercurius.util.ring :refer [ok]]))
 

src/mercurius/core/infraestructure/web/sente.clj renamed to src/mercurius/core/infrastructure/web/sente.clj

@@ -1,4 +1,4 @@
-(ns mercurius.core.infraestructure.web.sente
+(ns mercurius.core.infrastructure.web.sente
   (:require [taoensso.sente :as sente]
             [taoensso.sente.server-adapters.http-kit :refer [get-sch-adapter]]
             [clojure.core.async :refer [go-loop <!]]

src/mercurius/core/infraestructure/web/server.clj renamed to src/mercurius/core/infrastructure/web/server.clj

@@ -1,6 +1,6 @@
-(ns mercurius.core.infraestructure.web.server
+(ns mercurius.core.infrastructure.web.server
   (:require [org.httpkit.server :refer [run-server]]
-            [mercurius.core.infraestructure.web.handler :refer [handler]]
+            [mercurius.core.infrastructure.web.handler :refer [handler]]
             [taoensso.timbre :as log]))
 
 (defn start-web-server [{:keys [port] :or {port 3000} :as deps}]

test/mercurius/core/infraestructure/messaging/channel_based_pub_sub_test.clj renamed to test/mercurius/core/infrastructure/messaging/channel_based_pub_sub_test.clj

@@ -1,12 +1,12 @@
-(ns mercurius.core.infraestructure.messaging.channel-based-pub-sub-test
+(ns mercurius.core.infrastructure.messaging.channel-based-pub-sub-test
   (:require [clojure.test :refer [deftest testing is]]
             [mercurius.support.helpers :refer [with-system]]
             [mercurius.core.adapters.messaging.pub-sub :refer [publish subscribe]]
-            [mercurius.core.infraestructure.messaging.channel-based-pub-sub :refer [match-topic?]]))
+            [mercurius.core.infrastructure.messaging.channel-based-pub-sub :refer [match-topic?]]))
 
 (deftest pub-sub-test
   (testing "one subscriber to a specific topic"
-    (with-system [{pub-sub :infraestructure/pub-sub} {:only [:infraestructure/pub-sub]}]
+    (with-system [{pub-sub :infrastructure/pub-sub} {:only [:infrastructure/pub-sub]}]
       (let [msgs (atom [])]
         (subscribe pub-sub "t1" {:on-message #(swap! msgs conj %)})
         (publish pub-sub "t1" "m1")
@@ -15,7 +15,7 @@
         (is (match-eventually? ["m1" "m2"] msgs)))))
 
   (testing "multiple subscribers to the same specific topic"
-    (with-system [{pub-sub :infraestructure/pub-sub} {:only [:infraestructure/pub-sub]}]
+    (with-system [{pub-sub :infrastructure/pub-sub} {:only [:infrastructure/pub-sub]}]
       (let [topic "some topic"
             msgs (atom [])]
         (subscribe pub-sub topic {:on-message #(swap! msgs conj {:sub 1 :msg %})})
@@ -24,7 +24,7 @@
         (is (match-eventually? [{:sub 1 :msg "msg"} {:sub 2 :msg "msg"}] msgs)))))
 
   (testing "subscribing with a pattern"
-    (with-system [{pub-sub :infraestructure/pub-sub} {:only [:infraestructure/pub-sub]}]
+    (with-system [{pub-sub :infrastructure/pub-sub} {:only [:infrastructure/pub-sub]}]
       (let [msgs (atom [])]
         (subscribe pub-sub "events.*" {:on-message #(swap! msgs conj %)})
         (publish pub-sub "events.orders" "m1")