vvvvalvalval

This Gist shows how you may want to implement a forkable Ring Session Store for development and testing.

vvvvalvalval

log4j.rootLogger=INFO, syslog

log4j.appender.syslog=org.apache.log4j.net.SyslogAppender
log4j.appender.syslog.Facility=LOCAL7
log4j.appender.syslog.FacilityPrinting=false
log4j.appender.syslog.Header=true
log4j.appender.syslog.SyslogHost=<PAPERTRAIL_HOST>.papertrailapp.com:<PAPERTRAIL_PORT>
log4j.appender.syslog.layout=org.apache.log4j.PatternLayout
log4j.appender.syslog.layout.ConversionPattern==%p: (%F:%L) %x %m %n

vvvvalvalval

;; Imagine you have Persons and Dogs entities in you database, with a :dog/master relationship from Dogs to Persons

;; you want a report of how many dog each person in you database has, as a set of [<person-name> <number-of-dogs>], e.g:

#{["John Doe" 3]
  ["Foo bar" 0]
  ["Chuck Norris" 1]}

;; in particular, you want person who do not have a dog to appear in this report.

vvvvalvalval

(ns bs.utils.mock-connection
  "Utilities for using Datomic"
  (:require [datomic.api :as d])
  (:use clojure.repl clojure.pprint)
  (:import (java.util.concurrent BlockingQueue LinkedBlockingDeque)
           (datomic Connection)))

(defrecord MockConnection
  [dbAtom, ^BlockingQueue txQueue]

vvvvalvalval

(defmacro m:p "Makes a map from a list of symbols, using the symbol names to create keyword keys.
---
(let [a 1 b 2 c \"3\"]
  (m:p a b c))
=> {:a 1, :b 2, :c \"3\"}
" [& syms]
  (reduce (fn [m sym]
            (assert (symbol? sym) "m:p only accepts symbols")
            (assoc m (keyword (name sym)) sym)) 
          {} syms))

vvvvalvalval

(ns bs.utils.schema-cleaner "TL;DR look in the tests how the `cleaner` function is used."
  (:require [schema.core :as s]
            [schema.coerce :as sco]
            [schema.utils :as scu]
            )
  (:use clojure.repl clojure.pprint))

(deftype ^:private GarbageType [])
(def ^:private garbage-const (GarbageType.))

vvvvalvalval

;; defining helper function
[{:db/id #db/id[:db.part/user]
  :db/doc "Helper function for defining entity fields schema attributes in a concise way."
  :db/ident :utils/field
  :db/fn #db/fn {:lang :clojure
                 :require [datomic.api :as d]
                 :params [_ ident type doc opts]
                 :code [(cond-> {:db/cardinality :db.cardinality/one
                                 :db/fulltext true
                                 :db/index true

vvvvalvalval

;; Synchronous Clojure trained us to use Exceptions, while asynchronous JavaScript has trained us to use Promises.
;; In contexts where we work asynchronously in Clojure (in particular ClojureScript), it can be difficult to see a definite way of managing failure. Here are some proposals.

;; OPTION 1: adapting exception handling to core.async CSPs
;; As proposed by David Nolen, with some macro sugar we use Exceptions in go blocks with core async in the same way we would do with synchronous code.

(require '[clojure.core.async :as a :refer [go]])

;; defining some helper macros
(defn throw-err "Throw if is error, will be different in ClojureScript"

vvvvalvalval

;; Instead of this version, where you have to manage the lifecycle of my-stateful-component with React lifecycle methods

(defn parent-component []
  [:div
   ;; ...
   [my-stateful-component dynamic-id arg1 arg2 etc.]
   ;; ...
   ])

;; ... you can use this trick

vvvvalvalval

(require '[monger.collection :as mc])
(require '[monger.operators :as mop])

(defn populate "Populates the given docs sequence by looking up the 'foreign key' as an :_id in `foreign-coll`.

`foreign-path` can be either a single key or a sequence of keys (as in get-in)
Assumes the foreign keys are ObjectIds or coercable to objectIds.

Returns a seq of the docs where the foreign keys have been updated to be the foreign documents, in the same order.
"