backtrace from CIDER freeze

cider-backtrace.out

Debugger entered--Lisp error: (quit)
  fci-get-buffer-windows(t)
  fci-extend-rule-for-deletion(333368 333369)
  delete-char(-1)
  nrepl--pp((dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\""))
  nrepl--pp((dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...))
  nrepl--pp((dict "aliases" (dict) "interns" (dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...)))
  nrepl--pp((dict "G__42156" (dict "aliases" (dict) "interns" (dict)) "aggregate.core" (dict "aliases" (dict "jdbc" "clojure.java.jdbc" "p" "parsargs.core") "interns" (dict "->1" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :one> relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "->mn" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many> relationship.\\n  Available options:\\n  :query-fn         A function returning records by a foreign key.\\n  :update-links-fn  A function for updating link table records.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to false.\"") "->n" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :query-fn         A function returning records by a foreign key.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "default-fk" (dict "arglists" "([entity-kw])" "doc" "\"Returns a keyword that has the suffix '_id'.\"") "default-link-tablename" (dict "arglists" "([a-entity-kw b-entity-kw])" "doc" "\"Takes two tablenames and joins them with '_' and returns the result as keyword.\"") "delete!" (dict "arglists" "([er-config db-spec m] [er-config db-spec entity-kw m-or-id])" "doc" "\"Removes an aggregate datastructure from the database.\\n  Returns the number of deleted records.\"") "delete-dependants!" (dict "arglists" "([er-config db-spec id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw update-links-fn owned?]}]])" "doc" "\"Deletes all records that m contains, and that point by foreign key to m.\\n  Returns the number of deleted records.\"") "delete-prerequisite!" (dict "arglists" "([er-config db-spec m [relation-kw {:keys [relation-type entity-kw fk-kw owned?]}]])" "doc" "\"Deletes a record that m points to by a foreign key.\\n  Returns the number of deleted records or nil.\"") "dissoc-ks" (dict "arglists" "([m ks])" "doc" "\"Remove keys in ks from m.\"") "entity" (dict "arglists" "([& args])" "doc" "\"Returns an entity-spec from an entity keyword, an optional\\n  options-map and an arbitrary number of relation-specs, i.e.\\n      (agg/entity entity-kw options-map? relations)\\n  Available options:\\n  :read-fn       A function (fn [db-spec id]) returning the\\n                 record with primary key value id as a map.\\n  :insert-fn     A function (fn [db-spec row-map]) that inserts\\n                 the row-map as record, and returns the row-map\\n                 containing the new primary key value.\\n  :update-fn     A function (fn [db-spec set-map]) that updates\\n                 the record identified by the primary key value\\n                 within set-map with the values of set-map.\\n  :delete-fn     A function (fn [db-spec id]) that deletes the\\n                 record identified by the primary key value.\\n  :id-kw         The keyword to be used to get/assoc the primary\\n                 key value. It is also used as primary key\\n                 column name in default DB access functions.\"") "entity-parser" (dict) "entityspec?" (dict "arglists" "([x])" "doc" "\"Returns true if x is a vector containing a keyword as first and a\\n  map as second item\"") "er-config-parser" (dict) "extract-id" (dict "arglists" "([id-kw insert-result])" "doc" "\"Extracts id value from results like ({:scope_identity() 2}) or ({:id 2, ...}).\"") "keep-ks" (dict "arglists" "([m ks])" "doc" "\"Removes all but ks keys from map m.\"") "load" (dict "arglists" "([er-config db-spec entity-kw id] [er-config db-spec m])" "doc" "\"Loads an aggregate by `id`. The `entity-kw` denotes the aggregate root.\\n  Returns a map containing the entity-kw in ::entity and all data, or\\n  nil if the entity-kw is unknown or the record does not exist.\"") "load-relation" (dict "arglists" "([er-config db-spec visited id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw query-fn]}]])" "doc" "\"Loads more data according to the specified relation.\"") "load-relations" (dict "arglists" "([er-config db-spec visited m])") "log" (dict "arglists" "([& xs])") "make-delete-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns a delete function [db-spec id -> (Seq id)] for a specific\\n  table, which deletes the record id points to. It returns the number\\n  of deleted records (usually 1), or nil if none was deleted.\\n  The tablename may be passed as string or keyword.\"") "make-entity-options" (dict "arglists" "([tablename] [tablename id-kw])" "doc" "\"Returns a map containing all four default JDBC based implementations\\n  for read, insert, update and delete.\"") "make-er-config" (dict "arglists" "([& args])" "doc" "\"Creates a er-config map from an optional options-map and an\\n  arbitrary number of entity-specs, i.e.\\n      (agg/make-er-config options-map? entities)\\n  Available options:\\n  :read-fn-factory          A function (fn [tablename]) returning the\\n                            default read function.\\n  :insert-fn-factory        A function (fn [tablename]) returning the\\n                            default insert function.\\n  :update-fn-factory        A function (fn [tablename]) returning the\\n                            default update function.\\n  :delete-fn-factory        A function (fn [tablename]) returning the\\n                            default delete function.\\n  :query-<many-fn-factory   A function (fn [tablename fk-kw]) returning\\n                            the default query-for-many function using\\n                            one foreign key.\\n  :query-<many>-fn-factory  A function (fn [tablename linktablename fk-a fk-b])\\n                            returning the default query-for-many function\\n                            that uses a linktable.\\n  :update-links-fn-factory  A function (fn [linktablename fk-a fk-b])\\n                            returning the default function to update\\n                            link tables.\\n  :id-kw                    A keyword that is taken as default primary\\n                            key column name.\\n  :persisted-pred-fn        A predicate (fn [db-spec entity-kw id-kw row-map])\\n                            that returns true if the given row-map is already\\n                            present in DB.\"") "make-insert-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns an insert function [db-spec row-map -> row-map] for a specific table.\\n  It returns the record, possibly augmented with the generated id in\\n  an :id slot. The tablename may be passed as string or keyword.\"") "make-query-<many-fn" (dict "arglists" "([tablename fk-kw])" "doc" "\"Returns a finder function [db-spec id -> (Seq Map)] for a specific\\n  table, that returns -- as sequence of maps -- all records that have\\n  id as value of the foreign key field denoted by fk-kw.\\n  Assumes a simple n to 1 relationship.\"") "make-query-<many>-fn" ...)) "buddy.hashers" (dict "aliases" (dict "bytes" "buddy.core.bytes" "codecs" "buddy.core.codecs" "hash" "buddy.core.hash" "nonce" "buddy.core.nonce" "scrypt" "clojurewerkz.scrypt.core" "str" "clojure.string") "interns" (dict "+iterations+" (dict) "check" (dict "arglists" "([attempt encrypted] [attempt encrypted {:keys [limit setter prefered]}])" "doc" "\"Check if a unencrypted password matches\\n  with another encrypted password.\"") "check-password" (dict "doc" "\"Password verification implementation.\"") "derive" (dict "arglists" "([password] [password options])" "doc" "\"Encrypts a raw string password.\"") "derive-password" (dict "doc" "\"Derive key depending on algorithm.\"") "derive-password-for-legacy-pbkdf2+sha256" (dict "arglists" "([{:keys [alg password salt saltsize iterations]}])") "dispatch" (dict "arglists" "([opts & args])") "encrypt" (dict "doc" "\"Backward compatibility alias for `derive`.\"") "format-password" (dict "doc" "\"Format password depending on algorithm.\"") "must-update?" (dict "doc" "\"Check if the current password configuration\\n  is succeptible to be updatable.\"") "parse-password" (dict "doc" "\"Parse password from string to parts.\""))) "cemerick.url" (dict "aliases" (dict "pathetic" "pathetic.core" "string" "clojure.string") "interns" (dict "->URL" (dict "arglists" "([protocol username password host port path query anchor])" "doc" "\"Positional factory function for class cemerick.url.URL.\"") "map->URL" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class cemerick.url.URL, taking a map of keywords to field values.\"") "map->query" (dict "arglists" "([m])") "port-str" (dict "arglists" "([protocol port])") "query->map" (dict "arglists" "([qstr])") "split-param" (dict "arglists" "([param])") "url" (dict "arglists" "([url] [base-url & path-segments])" "doc" "\"Returns a new URL record for the given url string(s).\\n\\n   The first argument must be a base url — either a complete url string, or\\n   a pre-existing URL record instance that will serve as the basis for the new\\n   URL.  Any additional arguments must be strings, which are interpreted as\\n   relative paths that are successively resolved against the base url's path\\n   to construct the final :path in the returned URL record. \\n\\n   This function does not perform any url-encoding.  Use `url-encode` to encode\\n   URL path segments as desired before passing them into this fn.\"") "url*" (dict "arglists" "([url])") "url-creds" (dict "arglists" "([username password])") "url-decode" (dict "arglists" "([string] [string encoding])") "url-encode" (dict "arglists" "([string])"))) "clauth.middleware" (dict "aliases" (dict "token" "clauth.token") "interns" (dict "assoc-session" (dict "arglists" "([response req attr value])" "doc" "\"Add session varia\"") "authentication-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 401 Response\"") "csrf-protect!" (dict "arglists" "([app])" "doc" "\"add a csrf token to session and reject a post request without it\"") "csrf-token" (dict "arglists" "([req])" "doc" "\"extract csrf token from request\"") "if-form" (dict "arglists" "([req html api])" "doc" "\"if request is url form encoded it runs the first handler if not the second\"" "macro" "true") "if-html" (dict "arglists" "([req html api])" "doc" "\"if request is for a html page it runs the first handler if not the second\"" "macro" "true") "is-form?" (dict "arglists" "([req])" "doc" "\"returns true if request has form in the accept header\"") "is-html?" (dict "arglists" "([req])" "doc" "\"returns true if request has text/html in the accept header\"") "redirect" (dict "arglists" "([url] [url status])" "doc" "\"Returns a Ring response for an HTTP 302 redirect. Status may be \\n  a key in redirect-status-codes or a numeric code. Defaults to 302\"") "req->session-token-string" (dict "arglists" "([req])" "doc" "\"Return the token string from a session\"") "req->token" (dict "arglists" "([req] [req finder])") "req->token-string" (dict "arglists" "([req])" "doc" "\"Return the token string for a request\"") "requested-uri" (dict "arglists" "([req])") "require-bearer-token!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n\\n   The token is added to the :access-token key of the request.\\n\\n   will return a [HTTP 401 header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.4) if no valid token is present.\"") "require-user-session!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require that user is authenticated via an access_token stored in the session.\\n\\n   Use this to protect parts of your application that web services should not\\n   have access to.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   The token is added to the :access-token key of the request.\\n\\n   Will redirect user to login url if not authenticated and issue a 403 to\\n   other requests.\"") "user-session-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 403 Response or redirects to login\"") "with-csrf-token" (dict "arglists" "([req])" "doc" "\"add a csrf token to request\"") "wrap-bearer-token" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n   The subject is added to the :access-token key of the request.\"") "wrap-user-session" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 token stored in the session. Use this for\\n   optional authentication where no API access is wished.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   The subject is added to the :access-token key of the request.\""))) "clauth.user" (dict "aliases" (dict "cheshire" "cheshire.core" "store" "clauth.store") "interns" (dict "authenticate-user" (dict "arglists" "([login password])" "doc" "\"authenticate user application using login and password\"") "bcrypt" (dict "arglists" "([password])" "doc" "\"Perform BCrypt hash of password\"") "fetch-user" (dict "arglists" "([t])" "doc" "\"Find user based on login\"") "new-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"Create new user record\"") "register-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"create a unique user and store it in the user store\"") "reset-user-store!" (dict "arglists" "([])" "doc" "\"mainly for used in testing. Clears out all users.\"") "store-user" (dict "arglists" "([t])" "doc" "\"Store the given User and return it.\"") "user-store" (dict) "users" (dict "arglists" "([])" "doc" "\"Sequence of users\"") "valid-password?" (dict "arglists" "([candidate hashed])" "doc" "\"Verify that candidate password matches the hashed bcrypted password\""))) "clj-http.client" (dict "aliases" (dict "conn" "clj-http.conn-mgr" "core" "clj-http.core" "str" "clojure.string" "util" "clj-http.util") "interns" (dict "*current-middleware*" (dict "doc" "\"Available at any time to retrieve the middleware being used.\\n  Automatically bound when `with-middleware` is used.\"") "accept-encoding-value" (dict "arglists" "([accept-encoding])") "basic-auth-value" (dict "arglists" "([basic-auth])") "check-url!" (dict "arglists" "([url])") "client-error?" (dict "arglists" "([{:keys [status]}])") "coerce-clojure-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-content-type" (dict) "coerce-form-params" (dict) "coerce-form-urlencoded-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-json-body" (dict "arglists" "([{:keys [coerce]} {:keys [body status], :as resp} keyword? strict? & [charset]])") "coerce-response-body" (dict) "coerce-transit-body" (dict "arglists" "([{:keys [transit-opts], :as request} {:keys [body], :as resp} type])") "coerce-transit-form-params" (dict "arglists" "([type {:keys [form-params transit-opts]}])") "conflict?" (dict "arglists" "([{:keys [status]}])") "content-type-value" (dict "arglists" "([type])") "copy" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "crouton-enabled?" (dict) "decompress-body" (dict) "default-middleware" (dict "doc" "\"The default list of middleware clj-http uses for wrapping requests.\"") "delete" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "detect-charset" (dict "arglists" "([content-type])" "doc" "\"Given a charset header, detect the charset, returns UTF-8 if not found.\"") "dissoc-in" (dict "arglists" "([m [k & ks :as keys]])" "doc" "\"Dissociates an entry from a nested associative structure returning a new\\n  nested structure. keys is a sequence of keys. Any empty maps that result\\n  will not be present in the new structure.\"") "edn-enabled?" (dict) "follow-redirect" (dict "arglists" "([client {:keys [uri url scheme server-name server-port], :as req} {:keys [trace-redirects body], :as resp}])" "doc" "\"Attempts to follow the redirects from the \\\"location\\\" header, if no such\\n  header exists (bad server!), returns the response without following the\\n  request.\"") "form-decode" ...)) "clj-time.coerce" (dict "aliases" (dict "time-fmt" "clj-time.format") "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "ICoerce" (dict) "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" ...)) "clj-time.core" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" (dict "arglists" "([this])" "doc" "\"Returns the first day of the month\"") "floor" ...)) "clj-time.format" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "Mappable" (dict) "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" ...)) "clj-time.periodic" (dict "aliases" (dict "ct" "clj-time.core") "interns" (dict "periodic-seq" (dict "arglists" "([start period-like] [start end period-like])" "doc" "\"Returns a sequence of date-time values growing over specific period.\\n  The 2 argument function takes as input the starting value and the growing value,\\n  returning a lazy infinite sequence.\\n  The 3 argument function takes as input the starting value, the upper bound value,\\n  and the growing value, return a lazy sequence.\""))) "clojure.core.async" (dict "aliases" (dict "buffers" "clojure.core.async.impl.buffers" "channels" "clojure.core.async.impl.channels" "conc" "clojure.core.async.impl.concurrent" "core" "clojure.core" "dispatch" "clojure.core.async.impl.dispatch" "impl" "clojure.core.async.impl.protocols" "ioc" "clojure.core.async.impl.ioc-macros" "mutex" "clojure.core.async.impl.mutex" "timers" "clojure.core.async.impl.timers") "interns" (dict "<!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Must be called inside a (go ...) block. Will\\n  return nil if closed. Will park if nothing is available.\"") "<!!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Will return nil if closed. Will block\\n  if nothing is available.\"") ">!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Must be called\\n  inside a (go ...) block. Will park if no buffer space is available.\\n  Returns true unless port is already closed.\"") ">!!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Will block if no\\n  buffer space is available. Returns true unless port is already closed.\"") "Mix" (dict) "Mult" (dict) "Mux" (dict) "Pub" (dict) "admix" (dict "arglists" "([mix ch])" "doc" "\"Adds ch as an input to the mix\"") "admix*" (dict "arglists" "([m ch])") "alt!" (dict "arglists" "([& clauses])" "doc" "\"Makes a single choice between one of several channel operations,\\n  as if by alts!, returning the value of the result expr corresponding\\n  to the operation completed. Must be called inside a (go ...) block.\\n\\n  Each clause takes the form of:\\n\\n  channel-op[s] result-expr\\n\\n  where channel-ops is one of:\\n\\n  take-port - a single port to take\\n  [take-port | [put-port put-val] ...] - a vector of ports as per alts!\\n  :default | :priority - an option for alts!\\n\\n  and result-expr is either a list beginning with a vector, whereupon that\\n  vector will be treated as a binding for the [val port] return of the\\n  operation, else any other expression.\\n\\n  (alt!\\n    [c t] ([val ch] (foo ch val))\\n    x ([v] v)\\n    [[out val]] :wrote\\n    :default 42)\\n\\n  Each option may appear at most once. The choice and parking\\n  characteristics are those of alts!.\"" "macro" "true") "alt!!" (dict "arglists" "([& clauses])" "doc" "\"Like alt!, except as if by alts!!, will block until completed, and\\n  not intended for use in (go ...) blocks.\"" "macro" "true") "alt-flag" (dict "arglists" "([])") "alt-handler" (dict "arglists" "([flag cb])") "alts!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Completes at most one of several channel operations. Must be called\\n  inside a (go ...) block. ports is a vector of channel endpoints,\\n  which can be either a channel to take from or a vector of\\n  [channel-to-put-to val-to-put], in any combination. Takes will be\\n  made as if by <!, and puts will be made as if by >!. Unless\\n  the :priority option is true, if more than one port operation is\\n  ready a non-deterministic choice will be made. If no operation is\\n  ready and a :default value is supplied, [default-val :default] will\\n  be returned, otherwise alts! will park until the first operation to\\n  become ready completes. Returns [val port] of the completed\\n  operation, where val is the value taken for takes, and a\\n  boolean (true unless already closed, as per put!) for puts.\\n\\n  opts are passed as :key val ... Supported options:\\n\\n  :default val - the value to use if none of the operations are immediately ready\\n  :priority true - (default nil) when true, the operations will be tried in order.\\n\\n  Note: there is no guarantee that the port exps or val exprs will be\\n  used, nor in what order should they be, so they should not be\\n  depended upon for side effects.\"") "alts!!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Like alts!, except takes will be made as if by <!!, and puts will\\n  be made as if by >!!, will block until completed, and not intended\\n  for use in (go ...) blocks.\"") "bounded-count" (dict "arglists" "([n coll])" "doc" "\"Returns the smaller of n or the count of coll, without examining\\n  more than n items if coll is not counted\"") "buffer" (dict "arglists" "([n])" "doc" "\"Returns a fixed buffer of size n. When full, puts will block/park.\"") "chan" (dict "arglists" "([] [buf-or-n] [buf-or-n xform] [buf-or-n xform ex-handler])" "doc" "\"Creates a channel with an optional buffer, an optional transducer\\n  (like (map f), (filter p) etc or a composition thereof), and an\\n  optional exception-handler.  If buf-or-n is a number, will create\\n  and use a fixed buffer of that size. If a transducer is supplied a\\n  buffer must be specified. ex-handler must be a fn of one argument -\\n  if an exception occurs during transformation it will be called with\\n  the Throwable as an argument, and any non-nil return value will be\\n  placed in the channel.\"") "close!" (dict "arglists" "([chan])" "doc" "\"Closes a channel. The channel will no longer accept any puts (they\\n  will be ignored). Data in the channel remains available for taking, until\\n  exhausted, after which takes will return nil. If there are any\\n  pending takes, they will be dispatched with nil. Closing a closed\\n  channel is a no-op. Returns nil.\\n\\n  Logically closing happens after all puts have been delivered. Therefore, any\\n  blocked or parked puts will remain blocked/parked until a taker releases them.\"") "do-alt" (dict "arglists" "([alts clauses])") "do-alts" (dict "arglists" "([fret ports opts])" "doc" "\"returns derefable [val port] if immediate, nil if enqueued\"") "dropping-buffer" (dict "arglists" "([n])" "doc" "\"Returns a buffer of size n. When full, puts will complete but\\n  val will be dropped (no transfer).\"") "fhnop" (dict) "filter<" ...)) "clojure.data.json" (dict "aliases" (dict "pprint" "clojure.pprint") "interns" (dict "*bigdec*" (dict) "*escape-js-separators*" (dict) "*escape-slash*" (dict) "*escape-unicode*" (dict) "*key-fn*" (dict) "*value-fn*" (dict) "-read" (dict "arglists" "([stream eof-error? eof-value])") "-write" (dict "arglists" "([object out])" "doc" "\"Print object to PrintWriter out as JSON\"") "JSONWriter" (dict) "codepoint" (dict "arglists" "([c])" "macro" "true") "codepoint-case" (dict "arglists" "([e & clauses])" "macro" "true") "codepoint-clause" (dict "arglists" "([[test result]])") "default-value-fn" (dict "arglists" "([k v])") "default-write-key-fn" (dict "arglists" "([x])") "json-str" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write-str'.\\n\\n  Converts x to a JSON-formatted string.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn of \\\\uXXXX escapes of Unicode characters.\"") "pprint" (dict "arglists" "([x & options])" "doc" "\"Pretty-prints JSON representation of x to *out*. Options are the\\n  same as for write except :value-fn, which is not supported.\"") "pprint-array" (dict "arglists" "([s])") "pprint-dispatch" (dict "arglists" "([x])") "pprint-generic" (dict "arglists" "([x])") "pprint-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'pprint'.\\n\\n  Pretty-prints JSON representation of x to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "pprint-object" (dict "arglists" "([m])") "print-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write' to *out*.\\n\\n  Write JSON-formatted output to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "read" (dict "arglists" "([reader & options])" "doc" "\"Reads a single item of JSON data from a java.io.Reader. Options are\\n  key-value pairs, valid options are:\\n\\n     :eof-error? boolean\\n\\n        If true (default) will throw exception if the stream is empty.\\n\\n     :eof-value Object\\n\\n        Object to return if the stream is empty and eof-error? is\\n        false. Default is nil.\\n\\n     :bigdec boolean\\n\\n        If true use BigDecimal for decimal numbers instead of Double.\\n        Default is false.\\n\\n     :key-fn function\\n\\n        Single-argument function called on JSON property names; return\\n        value will replace the property names in the output. Default\\n        is clojure.core/identity, use clojure.core/keyword to get\\n        keyword properties.\\n\\n     :value-fn function\\n\\n        Function to transform values in maps (\\\"objects\\\" in JSON) in\\n        the output. For each JSON property, value-fn is called with\\n        two arguments: the property name (transformed by key-fn) and\\n        the value. The return value of value-fn will replace the value\\n        in the output. If value-fn returns itself, the property will\\n        be omitted from the output. The default value-fn returns the\\n        value unchanged. This option does not apply to non-map\\n        collections.\"") "read-array" (dict "arglists" "([stream])") "read-decimal" ...)) "clojure.java.jdbc" (dict "aliases" (dict "str" "clojure.string" "walk" "clojure.walk") "interns" (dict "Connectable" (dict) "IResultSetReadColumn" (dict "doc" "\"Protocol for reading objects from the java.sql.ResultSet. Default\\n   implementations (for Object and nil) return the argument, and the\\n   Boolean implementation ensures a canonicalized true/false value,\\n   but it can be extended to provide custom behavior for special types.\"") "ISQLParameter" (dict "doc" "\"Protocol for setting SQL parameters in statement objects, which\\n   can convert from Clojure values. The default implementation just\\n   delegates the conversion to ISQLValue's sql-value conversion and\\n   uses .setObject on the parameter. It can be extended to use other\\n   methods of PreparedStatement to convert and set parameter values.\"") "ISQLValue" (dict "doc" "\"Protocol for creating SQL values from Clojure values. Default\\n   implementations (for Object and nil) just return the argument,\\n   but it can be extended to provide custom behavior to support\\n   exotic types supported by different databases.\"") "add-connection" (dict "arglists" "([db connection])") "as-properties" (dict "arglists" "([m])" "doc" "\"Convert any seq of pairs to a java.utils.Properties instance.\\n   Uses as-sql-name to convert both keys and values into strings.\"") "as-sql-name" (dict "arglists" "([f] [f x])" "doc" "\"Given a naming strategy function and a keyword or string, return\\n   a string per that naming strategy.\\n   A name of the form x.y is treated as multiple names, x, y, etc,\\n   and each are turned into strings via the naming strategy and then\\n   joined back together so x.y might become `x`.`y` if the naming\\n   strategy quotes identifiers with `.\"") "classnames" (dict "doc" "\"Map of classnames to subprotocols\"") "col-str" (dict "arglists" "([col entities])" "doc" "\"Transform a column spec to an entity name for SQL. The column spec may be a\\n  string, a keyword or a map with a single pair - column name and alias.\"") "create-table-ddl" (dict "arglists" "([table specs] [table specs opts])" "doc" "\"Given a table name and a vector of column specs return the DDL string for\\n  creating that table. An options map may be provided that can contain:\\n  :table-spec -- a string that is appended to the DDL -- and/or\\n  :entities -- a function to specify how column names are transformed.\"") "db-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or throws if there is none)\"") "db-do-commands" (dict "arglists" "([db sql-commands] [db transaction? sql-commands])" "doc" "\"Executes SQL commands on the specified database connection. Wraps the commands\\n  in a transaction if transaction? is true. transaction? can be ommitted and it\\n  defaults to true. Accepts a single SQL command (string) or a vector of them.\\n  Uses executeBatch. This may affect what SQL you can run via db-do-commands.\"") "db-do-execute-prepared-return-keys" (dict "arglists" "([db stmt param-group transaction?])" "doc" "\"Executes a PreparedStatement, optionally in a transaction, and (attempts to)\\n  return any generated keys.\"") "db-do-execute-prepared-statement" (dict "arglists" "([db stmt param-groups transaction?])" "doc" "\"Execute a PreparedStatement, optionally in a transaction.\"") "db-do-prepared" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. Each param-group is a seq of values for all of\\n  the parameters. transaction? can be omitted and defaults to true.\\n  The sql parameter can either be a SQL string or a PreparedStatement.\\n  Return a seq of update counts (one count for each param-group).\"") "db-do-prepared-return-keys" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. The param-group is a seq of values for all of\\n  the parameters. transaction? can be ommitted and will default to true.\\n  Return the generated keys for the (single) update/insert.\\n  A PreparedStatement may be passed in, instead of a SQL string, in which\\n  case :return-keys MUST BE SET on that PreparedStatement!\"") "db-find-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or nil if there is none)\"") "db-is-rollback-only" (dict "arglists" "([db])" "doc" "\"Returns true if the outermost transaction will rollback rather than\\n  commit when complete\"") "db-query-with-resultset" (dict "arglists" "([db sql-params func] [db sql-params func opts])" "doc" "\"Executes a query, then evaluates func passing in the raw ResultSet as an\\n   argument. The second argument is a vector containing either:\\n    [sql & params] - a SQL query, followed by any parameters it needs\\n    [stmt & params] - a PreparedStatement, followed by any parameters it needs\\n                      (the PreparedStatement already contains the SQL query)\\n  The opts map is passed to prepare-statement.\\n  Uses executeQuery. This may affect what SQL you can run via query.\"") "db-set-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will rollback rather than\\n  commit when complete\"") "db-transaction*" (dict "arglists" "([db func] [db func {:keys [isolation read-only?], :as opts}])" "doc" "\"Evaluates func as a transaction on the open database connection. Any\\n  nested transactions are absorbed into the outermost transaction. By\\n  default, all database updates are committed together as a group after\\n  evaluating the outermost body, or rolled back on any uncaught\\n  exception. If rollback is set within scope of the outermost transaction,\\n  the entire transaction will be rolled back rather than committed when\\n  complete.\\n  The isolation option may be :none, :read-committed, :read-uncommitted,\\n  :repeatable-read, or :serializable. Note that not all databases support\\n  all of those isolation levels, and may either throw an exception or\\n  substitute another isolation level.\\n  The read-only? option puts the transaction in readonly mode (if supported).\"") "db-unset-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will not rollback when complete\"") "delete!" (dict "arglists" "([db table where-clause] [db table where-clause {:keys [entities transaction?], :or {entities identity, transaction? true}}])" "doc" "\"Given a database connection, a table name and a where clause of columns to match,\\n  perform a delete. The options may specify how to transform column names in the\\n  map (default 'as-is') and whether to run the delete in a transaction (default true).\\n  Example:\\n    (delete! db :person [\\\"zip = ?\\\" 94546])\\n  is equivalent to:\\n    (execute! db [\\\"DELETE FROM person WHERE zip = ?\\\" 94546])\"") "delete-sql" (dict "arglists" "([table [where & params] entities])" "doc" "\"Given a table name, a where class and its parameters and an optional entities spec,\\n  return a vector of the SQL for that delete operation followed by its parameters. The\\n  entities spec (default 'as-is') specifies how to transform column names.\"") "direction" ...)) "clojure.pprint" (dict "aliases" (dict) "interns" (dict "*code-table*" (dict) "*current-length*" (dict) "*current-level*" (dict) "*default-page-width*" (dict) "*format-str*" (dict) "*print-base*" (dict "doc" "\"The base to use for printing integers and rationals.\"") "*print-circle*" (dict "doc" "\"Mark circular structures (N.B. This is not yet used)\"") "*print-lines*" (dict "doc" "\"Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)\"") "*print-miser-width*" (dict "doc" "\"The column at which to enter miser style. Depending on the dispatch table, \\nmiser style add newlines in more places to try to keep lines short allowing for further \\nlevels of nesting.\"") "*print-pprint-dispatch*" (dict "doc" "\"The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch\\nto modify.\"") "*print-pretty*" (dict "doc" "\"Bind to true if you want write to use pretty printing\"") "*print-radix*" (dict "doc" "\"Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, \\nor 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the \\nradix specifier is in the form #XXr where XX is the decimal value of *print-base* \"") "*print-right-margin*" (dict "doc" "\"Pretty printing will try to avoid anything going beyond this column.\\nSet it to nil to have pprint let the line be arbitrarily long. This will ignore all \\nnon-mandatory newlines.\"") "*print-shared*" (dict "doc" "\"Mark repeated structures rather than repeat them (N.B. This is not yet used)\"") "*print-suppress-namespaces*" (dict "doc" "\"Don't print namespaces with symbols. This is particularly useful when \\npretty printing the results of macro expansions\"") "*symbol-map*" (dict) "abort?" (dict "arglists" "([context])") "absolute-reposition" (dict "arglists" "([navigator position])") "absolute-tabulation" (dict "arglists" "([params navigator offsets])") "add-core-ns" (dict "arglists" "([amap])") "add-english-scales" (dict "arglists" "([parts offset])" "doc" "\"Take a sequence of parts, add scale numbers (e.g., million) and combine into a string\\noffset is a factor of 10^3 to multiply by\"") "add-to-buffer" (dict "arglists" "([this token])") "ancestor?" (dict "arglists" "([parent child])") "arg-navigator" (dict) "base-str" ...)) "clojure.set" (dict "aliases" (dict) "interns" (dict "bubble-max-key" (dict "arglists" "([k coll])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "index" (dict "arglists" "([xrel ks])" "doc" "\"Returns a map of the distinct values of ks in the xrel mapped to a\\n  set of the maps in xrel with the corresponding values of ks.\"") "intersection" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the intersection of the input sets\"") "join" (dict "arglists" "([xrel yrel] [xrel yrel km])" "doc" "\"When passed 2 rels, returns the rel corresponding to the natural\\n  join. When passed an additional keymap, joins on the corresponding\\n  keys.\"") "map-invert" (dict "arglists" "([m])" "doc" "\"Returns the map with the vals mapped to the keys.\"") "project" (dict "arglists" "([xrel ks])" "doc" "\"Returns a rel of the elements of xrel with only the keys in ks\"") "rename" (dict "arglists" "([xrel kmap])" "doc" "\"Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap\"") "rename-keys" (dict "arglists" "([map kmap])" "doc" "\"Returns the map with the keys in kmap renamed to the vals in kmap\"") "select" (dict "arglists" "([pred xset])" "doc" "\"Returns a set of the elements for which pred is true\"") "subset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a subset of set2?\"") "superset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a superset of set2?\"") "union" (dict "arglists" "([] [s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the union of the input sets\""))) "clojure.string" (dict "aliases" (dict) "interns" (dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...)) "clojure.walk" (dict "aliases" (dict) "interns" (dict "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\""))) "clojure.walk2" (dict "aliases" (dict) "interns" (dict "Walkable" (dict) "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form. For\\n  development use only: This function does not perfectly emulate\\n  macroexpansion by the Clojure compiler because it doesn't understand\\n  special forms like 'let'.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "walkt" (dict "arglists" "([coll f])" "doc" "\"If coll is a collection, applies f to each element of the collection\\n  and returns a collection of the results, of the same type and order\\n  as coll. If coll is not a collection, returns it unchanged. \\\"Same\\n  type\\\" means a type with the same behavior. For example, a hash-map\\n  may be returned as an array-map, but a a sorted-map will be returned\\n  as a sorted-map with the same comparator.\"") "walkt-default" (dict "arglists" "([coll f])") "walkt-transient" (dict "arglists" "([coll f])"))) "clostache.parser" (dict "aliases" (dict "io" "clojure.java.io" "str" "clojure.string") "interns" (dict "->Section" (dict "arglists" "([name body start end inverted])" "doc" "\"Positional factory function for class clostache.parser.Section.\"") "convert-path" (dict "arglists" "([tag open-delim close-delim data])" "doc" "\"Convert a tag with a dotted name to nested sections, using the\\n  supplied delimiters to access the value.\"") "convert-paths" (dict "arglists" "([template data])" "doc" "\"Converts tags with dotted tag names to nested sections.\"") "create-partial-replacements" (dict "arglists" "([template partials])" "doc" "\"Creates pairs of partial replacements.\"") "escape-html" (dict "arglists" "([string])" "doc" "\"Replaces angle brackets with the respective HTML entities.\"") "escape-regex" (dict "arglists" "([regex])" "doc" "\"Escapes characters that have special meaning in regular expressions.\"") "extract-section" (dict "arglists" "([template])" "doc" "\"Extracts the outer section from the template.\"") "find-section-end-tag" (dict "arglists" "([template index level])" "doc" "\"Find the matching end tag for a section at the specified level,\\n   starting to search at index.\"") "find-section-start-tag" (dict "arglists" "([template index])" "doc" "\"Find the next section start tag, starting to search at index.\"") "include-partials" (dict "arglists" "([template partials])" "doc" "\"Include partials within the template.\"") "indent-partial" (dict "arglists" "([partial indent])" "doc" "\"Indent all lines of the partial by indent.\"") "join-standalone-delimiter-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) delimiter tags.\"") "join-standalone-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) section/partials\\n   tags.\"") "map->Section" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class clostache.parser.Section, taking a map of keywords to field values.\"") "map-str" (dict "arglists" "([f coll])" "doc" "\"Apply f to each element of coll, concatenate all results into a\\n  String.\"") "next-index" (dict "arglists" "([section regex] [section regex index])" "doc" "\"Return the next index of the supplied regex.\"") "path-data" (dict "arglists" "([elements data])" "doc" "\"Extract the data for the supplied path.\"") "preprocess" (dict "arglists" "([template data partials])" "doc" "\"Preprocesses template and data (e.g. removing comments).\"") "process-set-delimiters" (dict "arglists" "([template data])" "doc" "\"Replaces custom set delimiters with mustaches.\"") "regex-chars" (dict) "remove-comments" (dict "arglists" "([template])" "doc" "\"Removes comments from the template.\"") "render" (dict "arglists" "([template] [template data] [template data partials])" "doc" "\"Renders the template with the data and, if supplied, partials.\"") "render-resource" (dict "arglists" "([path] [path data] [path data partials])" "doc" "\"Renders a resource located on the classpath\"") "render-section" (dict "arglists" "([section data partials])") "render-template" ...)) "crypto.random" (dict "aliases" (dict "string" "clojure.string") "interns" (dict "base32" (dict "arglists" "([size])" "doc" "\"Return a random base32 string of the specified size in bytes.\"") "base64" (dict "arglists" "([size])" "doc" "\"Return a random base64 string of the specified size in bytes.\"") "bytes" (dict "arglists" "([size])" "doc" "\"Returns a random byte array of the specified size.\"") "hex" (dict "arglists" "([size])" "doc" "\"Return a random hex string of the specified size in bytes.\"") "url-part" (dict "arglists" "([size])" "doc" "\"Return a random string suitable for being inserted into URLs. The size\\n  denotes the number of bytes to generate.\""))) "hugsql.core" (dict "aliases" (dict "adapter" "hugsql.adapter" "edn" "clojure.tools.reader.edn" "io" "clojure.java.io" "parameters" "hugsql.parameters" "parser" "hugsql.parser" "string" "clojure.string") "interns" (dict "adapter" (dict) "command-sym" (dict "arglists" "([hdr])") "compile-exprs" (dict "arglists" "([pdef])" "doc" "\"Compile (def) all expressions in a parsed def\"") "db-fn" (dict "arglists" "([sql] [sql command] [sql command result] [sql command result options])" "doc" "\"Given an sql string and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn*" (dict "arglists" "([psql] [psql command] [psql command result] [psql command result options])" "doc" "\"Given parsed sql and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn-map" (dict "arglists" "([pdef options])" "doc" "\"Hashmap of db fn from a parsed def\\n   with the form:\\n   {:fn-name {:meta {:doc \\\"doc string\\\"}\\n              :fn <anon-db-fn>}\"") "db-run" (dict "arglists" "([db sql] [db sql param-data] [db sql param-data command] [db sql param-data command result] [db sql param-data command result options & command-options])" "doc" "\"Given a database spec/connection, sql string,\\n   parameter data, and optional command, result,\\n   and options, run the sql statement\"") "def-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   :quoting options for identifiers are:\\n     :ansi double-quotes: \\\"identifier\\\"\\n     :mysql backticks: `identifier`\\n     :mssql square brackets: [identifier]\\n     :off no quoting (default)\\n\\n   Identifiers containing a period/dot . are split, quoted separately,\\n   and then rejoined. This supports myschema.mytable conventions.\\n\\n   :quoting can be overridden as an option in the calls to functions\\n   created by def-db-fns.\\n\\n   :adapter specifies the HugSQL adapter to use for all defined\\n   functions. The default adapter used is\\n   (hugsql.adapter.clojure-java-jdbc/hugsql-adapter-clojure-java-jdbc)\\n   when :adapter is not given.\\n\\n   See also hugsql.core/set-adapter! to set adapter for all def-db-fns\\n   calls.  Also, :adapter can be specified for individual function\\n   calls (overriding set-adapter! and the :adapter option here).\"" "macro" "true") "def-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "def-expr" (dict "arglists" "([expr] [expr require-str])") "def-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "def-sqlvec-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns-from-string s options?)\\n\\n   where:\\n    - s is a HugSQL-flavored sql string\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "default-db-options" (dict) "default-sqlvec-options" (dict) "expr-name" (dict "arglists" "([expr])") "expr-pass" (dict "arglists" "([sql-template params options])" "doc" "\"Takes an sql template (from hugsql parser) and evaluates the\\n  Clojure expressions resulting in returning an sql template\\n  containing only sql strings and hashmap parameters\"") "get-adapter" (dict "arglists" "([])" "doc" "\"Get an adapter.  Sets default\\n   hugsql.adapter.clojure-java-jdbc\\n   adapter if no adapter is set.\"") "hugsql-command-fn" (dict) "hugsql-result-fn" (dict) "intern-db-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the db fn from a parsed def\"") "intern-sqlvec-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the sqlvec fn from a parsed def\"") "map-of-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n  Usage:\\n\\n   (map-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "map-of-sqlvec-fns-from-string" ...)) "io.aviso.rook" (dict "aliases" (dict "dispatcher" "io.aviso.rook.dispatcher" "medley" "medley.core" "p" "potemkin" "swagger" "io.aviso.rook.swagger" "t" "io.aviso.tracker") "interns" (dict "compose-middleware" (dict "arglists" "([& middlewares])" "doc" "\"Assembles multiple endpoint middleware forms into a single endpoint middleware. Each middleware form\\n  is either a list or a single form, that will be wrapped as a list.\\n\\n  The list is modified so that the first two values passed in are the previous handler and the metadata (associated\\n  with the endpoint function).\\n\\n  The form should evaluate to a new handler, or the old handler. As a convienience, the form may\\n  evaluate to nil, which will keep the original handler passed in.\\n\\n  Returns a function that accepts a handler and middleware and invokes each middleware form in turn, returning\\n  a final handler function.\\n\\n  This is patterned on Clojure's -> threading macro, with some significant differences.\"" "macro" "true") "consume" (dict "arglists" "([coll bindings & body])" "doc" "\"Consume is used to break apart a collection into individual terms.\\n\\n  The format is:\\n\\n      (consume coll [symbol predicate arity ...] body)\\n\\n  The symbol is assigned a value by extracting zero or more values from the collection that\\n  match the predicate. The predicate is passed a single element from the\\n  collection and should return a truth value.\\n\\n  The arity is a keyword that identifies how many values are taken\\n  from the collection.\\n\\n  :one\\n  : The first value in the collection must match the predicate, or an exception is thrown.\\n    The value is assigned to the symbol.  The literal value 1 may be used instead of :one.\\n\\n  :?\\n  : Matches 0 or 1 values from the collection. If the first value does not match the predicate,\\n    then nil is assigned to the symbol.\\n\\n  :*\\n  : Zero or more values from the collection are assigned to the symbol. The symbol may be assigned\\n    an empty collection.\\n\\n  :+\\n  : Matches one or more values; an exception is thrown if there are no matches.\\n\\n  The symbol/pred/arity triplet can be followed by additional triplets.\\n\\n  Although the above description discusses triplets, there are two special predicate values\\n  that are used as just a pair (symbol followed by special predicate), with no arity.\\n\\n  :&\\n  : Used to indicate consumption of all remaining values, if any, from the collection.\\n    It is not followed by an arity, and must be the final term in the bindings vector.\\n\\n  :+\\n  : Used to consume a single value always (throwing an exception if the collection is\\n    empty).\\n\\n  consume expands into a let form, so the symbol in each triplet may be a destructuring form.\\n\\n  As an example, a function that expects an optional map followed by at least\\n  one string, followed by any number of vectors:\\n\\n\\n      (defn example\\n        {:arglists '([options strings... & vectors] [strings... & vectors])}\\n        [& args]\\n        (consume args\\n          [options map? :?       ; nil or a map\\n           strings string? :+    ; seq of strings, at least one\\n           vectors :&]           ; remaining arguments, may be empty\\n           ;; Use options, strings, vectors here\\n           ...))\\n  \"" "macro" "true") "find-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an optional injected value from the request, returning nil if the value does not exist.\"") "get-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an injected value stored in the request. Throws an exception if the value is falsey.\"") "inject" (dict "arglists" "([request key value])" "doc" "\"Merges a single keyword key and value into the map of injectable argument values store in the request.\\n  This is associated with the :injection argument metadata.\"") "inject*" (dict "arglists" "([request injection-map])" "doc" "\"Merges the provided map of injectable argument values into the request. Keys should be keywords\\n  (that will match against function argument symbols, converted to keywords).\"") "namespace-handler" (dict "arglists" "([options & ns-specs] [& ns-specs])" "doc" "\"Examines the given namespaces and produces either a Ring handler or\\n  an asynchronous Ring handler.\\n\\n  Options can be provided as a leading map (which is optional).\\n\\n  The individual namespaces are specified as vectors of the following\\n  shape:\\n\\n      [context? ns-sym argument-resolvers? middleware? nested...?]\\n\\n  The optional fragments are interpreted as below:\\n\\n  context?\\n  : A context (a string, or a vector of strings and/or keywords) to be prepended to paths for all entries\\n  emitted for this namespace.\\n\\n  ns-sym\\n  : The symbol for the namespace that is to be mapped.\\n  : This is the only required value in the namespace specification.\\n\\n  argument-resolvers?\\n  : A map of argument resolvers that apply to the namespace, and to any child namespaces.\\n\\n  middleware?\\n  : Middleware to be applied to terminal handlers found in this\\n  namespace.\\n\\n  nested...?\\n  : Defines child namespaces, each its own recursive namespace specification.\\n  Child namespaces inherit the context, argument resolvers, and middleware\\n  of the containing namespace.\\n\\n  Supported options and their default values:\\n\\n  :arg-resolvers\\n  : Map of symbol to (keyword or function of request) or keyword\\n    to (function of symbol returning function of request). Entries of\\n    the former provide argument resolvers to be used when resolving\\n    arguments named by the given symbol; in the keyword case, a known\\n    resolver factory will be used.\\n  : Normally, the provided map is merged into the map inherited from\\n    the containing namespace (or elsewhere), but this can be controlled\\n    using metadata on the map.\\n  : Tag with {:replace true} to\\n    exclude inherited resolvers and resolver factories; tag with\\n    {:replace-resolvers true} or {:replace-factories true} to leave\\n    out default resolvers or resolver factories, respectively.\\n\\n  :context\\n  : _Default: []_\\n  : A root context that all namespaces are placed under, for example [\\\"api\\\"].\\n\\n  :default-middleware\\n  : _Default: [[default-namespace-middleware]]_\\n  : Default endpoint middleware applied to the basic handler for\\n    each endpoint function (the basic handler resolver arguments and passes\\n    them to the endpoint function).\\n    The default leaves the basic handler unchanged.\\n\\n  :swagger-options\\n  : Options to be passed to [[construct-swagger-object]], that control how the Swagger description is composed and\\n    customized.\\n    Swagger support is only enabled when :swagger-options is non-nil.\\n\\n  Example call:\\n\\n       (namespace-handler\\n         {:context            [\\\"api\\\"]\\n          :swagger-options    swagger/default-swagger-options\\n          :default-middleware custom-middleware\\n          :arg-resolvers      {'if-unmodified-since :header\\n                               'if-modified-since   :header}}\\n         ;; foo & bar use custom-middleware:\\n         [\\\"hotels\\\" 'org.example.resources.hotels\\n           [[:hotel-id \\\"rooms\\\"] 'org.example.resources.rooms]]\\n         [\\\"bars\\\" 'org.example.resources.bars]\\n         ;; taxis has special requirements:\\n         [\\\"taxis\\\" 'org.example.resources.taxis\\n           {:dispatcher dispatcher-resolver-factory}\\n           taxi-middleware]).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "resolve-argument-value" (dict "arglists" "([request argument-meta argument-symbol])" "doc" "\"Resolves an argument, as if it were an argument to an endpoint function.\\n\\n  request\\n  : The Ring request map, as passed through middleware and to the endpoint.\\n\\n  argument-meta\\n  : A map of metadata about the symbol, or a single keyword. A keyword is converted\\n    to a map (of the keyword, to true).\\n\\n  argument-symbol\\n  : A symbol identifying the name of the parameter. This is sometimes needed to construct\\n    the argument resolver function.\\n\\n  Throws an exception if no (single) argument resolver can be identified.\"") "wrap-with-injection" (dict "arglists" "([handler key value])" "doc" "\"Wraps a request handler with an injection of the key and value.\"") "wrap-with-injections" (dict "arglists" "([handler injections])" "doc" "\"Wraps a request handler with injections by merging in a map.\"") "wrap-with-standard-middleware" (dict "arglists" "([handler])" "doc" "\"The standard middleware that Rook expects to be present before it is passed the Ring request.\""))) "io.aviso.rook.server" (dict "aliases" (dict "io" "clojure.java.io" "l" "clojure.tools.logging" "medley" "medley.core" "rook" "io.aviso.rook" "str" "clojure.string" "t" "io.aviso.tracker" "utils" "io.aviso.rook.utils") "interns" (dict "cond-let" (dict "arglists" "([& forms])" "doc" "\"A merging of cond and let.  Each term is either a vector\\n  (in which case, it acts like let) or a condition expression followed by the value\\n  for that expression. An empty cond-let returns nil.\\n\\n  cond-let makes it possible to create readable code that doesn't end up nesting\\n  ;endlessly.\\n\\n  A typical example is where several steps must occur, perhaps reading data from\\n  an external datastore and making a few consistency checks:\\n\\n      (defn apply-payment [db-conn order-id user-id payment-info]\\n        (cond-let\\n          [order (find-order-by-id db-conn order-id)]\\n\\n          (nil? order)\\n          not-found-response\\n\\n          (not (owned-by? order user-id))\\n          forbidden-response\\n\\n          [existing-payment (find-payment db-conn (:payment-id order))]\\n\\n          (some? existing-payment)\\n          already-payed-response\\n\\n          :else\\n          (do\\n            (attach-payment db-conn order payment-info)\\n\\n            updated-response)))\"" "macro" "true") "construct-handler" (dict "arglists" "([{:keys [reload log debug track standard exceptions lazy]} creator & creator-args])" "doc" "\"Constructs a root handler using a creator function.  Normally, the creator function\\n  is invoked immediately, and returns a Ring handler function. However, during development,\\n  to take advantage of code reloading, the creator will be invoked on each incoming request.\\n\\n  To fully take advantage of REPL oriented development, you should pass the Var containing\\n  the creator function, e.g. `#'create-app-handler`.\\n\\n  The optional creator-args are additional arguments to be passed to the creator function;\\n  these are usually configuration data or dependencies.\\n\\n  The options map contains several flags:\\n\\n  :reload\\n  : enables the above-described reloading of the handler.\\n\\n  :lazy\\n  : if true (and :reload is false) then the handler is not created until first needed, rather\\n    then immediately on invoking this function.\\n\\n  :debug\\n  : enables logging (at debug level) of each incoming request via [[wrap-debug-request]]\\n    and [[wrap-debug-response]]\\n\\n  :log\\n  : enables logging of a summary of each incoming request (at info level) via [[wrap-log-request]].\\n\\n  :track\\n  : enables tracking a summary of each incoming request via [[wrap-track-request]].\\n\\n  :standard\\n  : Enables the standard Rook middleware, (see [[wrap-with-standard-middleware]]).\\n\\n  :exceptions\\n  : Enables [[wrap-with-exception-catching]] to catch and report exceptions.\\n\\n  The extra middleware is added around the root handler (or the\\n  reloading handler that creates the root handler).\"") "format-binary" (dict "arglists" "([data & options])" "doc" "\"Formats the data using [[write-binary]] and returns the result as a string.\"") "format-bytes" (dict "arglists" "([label byte-array])") "lazy-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created lazily on first access.\"") "log-request-and-body" (dict "arglists" "([request body-array])") "log-response" (dict "arglists" "([response])" "doc" "\"Logs the response at debug level (if enabled) with nice formatting; returns a new response (since reading\\n  an InputStream body is destructive).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "read-bytes" (dict "arglists" "([stream length])") "reloading-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created fresh on each request;\\n  this is used when developing the application as it supports re-loading of code in a REPL without having to\\n  restart the embedded Jetty instance.\"") "to-message" (dict "arglists" "([t])" "doc" "\"Converts an exception to a message. Normally, this is the message property of the exception, but if\\n  that's blank, the fully qualified class name of the exception is used instead.\"") "wrap-creator" (dict "arglists" "([creator creator-args])" "doc" "\"Wraps a creator and arguments as a function of no arguments. If the creator fails, then\\n  the error is logged and a handler that always responds with a 500 status is returned.\"") "wrap-debug-request" (dict "arglists" "([handler])" "doc" "\"Logs a pretty-printed representation of each incoming request, at level debug. This includes output\\n  of the body's content in ASCII and hex; this means that the entire body (if present) may be consumed\\n  and stored in memory, and replaced with a new InputStream downstream (when debugging is enabled).\"") "wrap-debug-response" (dict "arglists" "([handler])" "doc" "\"Used to log the response sent back to the client at debug level.\"") "wrap-log-request" (dict "arglists" "([handler])" "doc" "\"Logs incoming requests (as info), identifying method and URI.\"") "wrap-track-request" (dict "arglists" "([handler])" "doc" "\"An alternative to [[wrap-log-request]]; adds tracking with a label via [[summarize-request]].\"") "wrap-with-exception-catching" (dict "arglists" "([handler])" "doc" "\"A simple exception catching and reporting wrapper.\\n\\n   Establishes a tracking checkpoint (so it works very well with [[wrap-track-request]].\\n\\n   Exceptions are converted to 500 responses in the standard [[failure-response]] format.\""))) "json-window.core" ...))
  nrepl--pp((<-- "changed-namespaces" (dict "G__42156" (dict "aliases" (dict) "interns" (dict)) "aggregate.core" (dict "aliases" (dict "jdbc" "clojure.java.jdbc" "p" "parsargs.core") "interns" (dict "->1" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :one> relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "->mn" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many> relationship.\\n  Available options:\\n  :query-fn         A function returning records by a foreign key.\\n  :update-links-fn  A function for updating link table records.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to false.\"") "->n" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :query-fn         A function returning records by a foreign key.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "default-fk" (dict "arglists" "([entity-kw])" "doc" "\"Returns a keyword that has the suffix '_id'.\"") "default-link-tablename" (dict "arglists" "([a-entity-kw b-entity-kw])" "doc" "\"Takes two tablenames and joins them with '_' and returns the result as keyword.\"") "delete!" (dict "arglists" "([er-config db-spec m] [er-config db-spec entity-kw m-or-id])" "doc" "\"Removes an aggregate datastructure from the database.\\n  Returns the number of deleted records.\"") "delete-dependants!" (dict "arglists" "([er-config db-spec id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw update-links-fn owned?]}]])" "doc" "\"Deletes all records that m contains, and that point by foreign key to m.\\n  Returns the number of deleted records.\"") "delete-prerequisite!" (dict "arglists" "([er-config db-spec m [relation-kw {:keys [relation-type entity-kw fk-kw owned?]}]])" "doc" "\"Deletes a record that m points to by a foreign key.\\n  Returns the number of deleted records or nil.\"") "dissoc-ks" (dict "arglists" "([m ks])" "doc" "\"Remove keys in ks from m.\"") "entity" (dict "arglists" "([& args])" "doc" "\"Returns an entity-spec from an entity keyword, an optional\\n  options-map and an arbitrary number of relation-specs, i.e.\\n      (agg/entity entity-kw options-map? relations)\\n  Available options:\\n  :read-fn       A function (fn [db-spec id]) returning the\\n                 record with primary key value id as a map.\\n  :insert-fn     A function (fn [db-spec row-map]) that inserts\\n                 the row-map as record, and returns the row-map\\n                 containing the new primary key value.\\n  :update-fn     A function (fn [db-spec set-map]) that updates\\n                 the record identified by the primary key value\\n                 within set-map with the values of set-map.\\n  :delete-fn     A function (fn [db-spec id]) that deletes the\\n                 record identified by the primary key value.\\n  :id-kw         The keyword to be used to get/assoc the primary\\n                 key value. It is also used as primary key\\n                 column name in default DB access functions.\"") "entity-parser" (dict) "entityspec?" (dict "arglists" "([x])" "doc" "\"Returns true if x is a vector containing a keyword as first and a\\n  map as second item\"") "er-config-parser" (dict) "extract-id" (dict "arglists" "([id-kw insert-result])" "doc" "\"Extracts id value from results like ({:scope_identity() 2}) or ({:id 2, ...}).\"") "keep-ks" (dict "arglists" "([m ks])" "doc" "\"Removes all but ks keys from map m.\"") "load" (dict "arglists" "([er-config db-spec entity-kw id] [er-config db-spec m])" "doc" "\"Loads an aggregate by `id`. The `entity-kw` denotes the aggregate root.\\n  Returns a map containing the entity-kw in ::entity and all data, or\\n  nil if the entity-kw is unknown or the record does not exist.\"") "load-relation" (dict "arglists" "([er-config db-spec visited id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw query-fn]}]])" "doc" "\"Loads more data according to the specified relation.\"") "load-relations" (dict "arglists" "([er-config db-spec visited m])") "log" (dict "arglists" "([& xs])") "make-delete-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns a delete function [db-spec id -> (Seq id)] for a specific\\n  table, which deletes the record id points to. It returns the number\\n  of deleted records (usually 1), or nil if none was deleted.\\n  The tablename may be passed as string or keyword.\"") "make-entity-options" (dict "arglists" "([tablename] [tablename id-kw])" "doc" "\"Returns a map containing all four default JDBC based implementations\\n  for read, insert, update and delete.\"") "make-er-config" (dict "arglists" "([& args])" "doc" "\"Creates a er-config map from an optional options-map and an\\n  arbitrary number of entity-specs, i.e.\\n      (agg/make-er-config options-map? entities)\\n  Available options:\\n  :read-fn-factory          A function (fn [tablename]) returning the\\n                            default read function.\\n  :insert-fn-factory        A function (fn [tablename]) returning the\\n                            default insert function.\\n  :update-fn-factory        A function (fn [tablename]) returning the\\n                            default update function.\\n  :delete-fn-factory        A function (fn [tablename]) returning the\\n                            default delete function.\\n  :query-<many-fn-factory   A function (fn [tablename fk-kw]) returning\\n                            the default query-for-many function using\\n                            one foreign key.\\n  :query-<many>-fn-factory  A function (fn [tablename linktablename fk-a fk-b])\\n                            returning the default query-for-many function\\n                            that uses a linktable.\\n  :update-links-fn-factory  A function (fn [linktablename fk-a fk-b])\\n                            returning the default function to update\\n                            link tables.\\n  :id-kw                    A keyword that is taken as default primary\\n                            key column name.\\n  :persisted-pred-fn        A predicate (fn [db-spec entity-kw id-kw row-map])\\n                            that returns true if the given row-map is already\\n                            present in DB.\"") "make-insert-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns an insert function [db-spec row-map -> row-map] for a specific table.\\n  It returns the record, possibly augmented with the generated id in\\n  an :id slot. The tablename may be passed as string or keyword.\"") "make-query-<many-fn" (dict "arglists" "([tablename fk-kw])" "doc" "\"Returns a finder function [db-spec id -> (Seq Map)] for a specific\\n  table, that returns -- as sequence of maps -- all records that have\\n  id as value of the foreign key field denoted by fk-kw.\\n  Assumes a simple n to 1 relationship.\"") "make-query-<many>-fn" ...)) "buddy.hashers" (dict "aliases" (dict "bytes" "buddy.core.bytes" "codecs" "buddy.core.codecs" "hash" "buddy.core.hash" "nonce" "buddy.core.nonce" "scrypt" "clojurewerkz.scrypt.core" "str" "clojure.string") "interns" (dict "+iterations+" (dict) "check" (dict "arglists" "([attempt encrypted] [attempt encrypted {:keys [limit setter prefered]}])" "doc" "\"Check if a unencrypted password matches\\n  with another encrypted password.\"") "check-password" (dict "doc" "\"Password verification implementation.\"") "derive" (dict "arglists" "([password] [password options])" "doc" "\"Encrypts a raw string password.\"") "derive-password" (dict "doc" "\"Derive key depending on algorithm.\"") "derive-password-for-legacy-pbkdf2+sha256" (dict "arglists" "([{:keys [alg password salt saltsize iterations]}])") "dispatch" (dict "arglists" "([opts & args])") "encrypt" (dict "doc" "\"Backward compatibility alias for `derive`.\"") "format-password" (dict "doc" "\"Format password depending on algorithm.\"") "must-update?" (dict "doc" "\"Check if the current password configuration\\n  is succeptible to be updatable.\"") "parse-password" (dict "doc" "\"Parse password from string to parts.\""))) "cemerick.url" (dict "aliases" (dict "pathetic" "pathetic.core" "string" "clojure.string") "interns" (dict "->URL" (dict "arglists" "([protocol username password host port path query anchor])" "doc" "\"Positional factory function for class cemerick.url.URL.\"") "map->URL" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class cemerick.url.URL, taking a map of keywords to field values.\"") "map->query" (dict "arglists" "([m])") "port-str" (dict "arglists" "([protocol port])") "query->map" (dict "arglists" "([qstr])") "split-param" (dict "arglists" "([param])") "url" (dict "arglists" "([url] [base-url & path-segments])" "doc" "\"Returns a new URL record for the given url string(s).\\n\\n   The first argument must be a base url — either a complete url string, or\\n   a pre-existing URL record instance that will serve as the basis for the new\\n   URL.  Any additional arguments must be strings, which are interpreted as\\n   relative paths that are successively resolved against the base url's path\\n   to construct the final :path in the returned URL record. \\n\\n   This function does not perform any url-encoding.  Use `url-encode` to encode\\n   URL path segments as desired before passing them into this fn.\"") "url*" (dict "arglists" "([url])") "url-creds" (dict "arglists" "([username password])") "url-decode" (dict "arglists" "([string] [string encoding])") "url-encode" (dict "arglists" "([string])"))) "clauth.middleware" (dict "aliases" (dict "token" "clauth.token") "interns" (dict "assoc-session" (dict "arglists" "([response req attr value])" "doc" "\"Add session varia\"") "authentication-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 401 Response\"") "csrf-protect!" (dict "arglists" "([app])" "doc" "\"add a csrf token to session and reject a post request without it\"") "csrf-token" (dict "arglists" "([req])" "doc" "\"extract csrf token from request\"") "if-form" (dict "arglists" "([req html api])" "doc" "\"if request is url form encoded it runs the first handler if not the second\"" "macro" "true") "if-html" (dict "arglists" "([req html api])" "doc" "\"if request is for a html page it runs the first handler if not the second\"" "macro" "true") "is-form?" (dict "arglists" "([req])" "doc" "\"returns true if request has form in the accept header\"") "is-html?" (dict "arglists" "([req])" "doc" "\"returns true if request has text/html in the accept header\"") "redirect" (dict "arglists" "([url] [url status])" "doc" "\"Returns a Ring response for an HTTP 302 redirect. Status may be \\n  a key in redirect-status-codes or a numeric code. Defaults to 302\"") "req->session-token-string" (dict "arglists" "([req])" "doc" "\"Return the token string from a session\"") "req->token" (dict "arglists" "([req] [req finder])") "req->token-string" (dict "arglists" "([req])" "doc" "\"Return the token string for a request\"") "requested-uri" (dict "arglists" "([req])") "require-bearer-token!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n\\n   The token is added to the :access-token key of the request.\\n\\n   will return a [HTTP 401 header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.4) if no valid token is present.\"") "require-user-session!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require that user is authenticated via an access_token stored in the session.\\n\\n   Use this to protect parts of your application that web services should not\\n   have access to.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   The token is added to the :access-token key of the request.\\n\\n   Will redirect user to login url if not authenticated and issue a 403 to\\n   other requests.\"") "user-session-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 403 Response or redirects to login\"") "with-csrf-token" (dict "arglists" "([req])" "doc" "\"add a csrf token to request\"") "wrap-bearer-token" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n   The subject is added to the :access-token key of the request.\"") "wrap-user-session" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 token stored in the session. Use this for\\n   optional authentication where no API access is wished.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   The subject is added to the :access-token key of the request.\""))) "clauth.user" (dict "aliases" (dict "cheshire" "cheshire.core" "store" "clauth.store") "interns" (dict "authenticate-user" (dict "arglists" "([login password])" "doc" "\"authenticate user application using login and password\"") "bcrypt" (dict "arglists" "([password])" "doc" "\"Perform BCrypt hash of password\"") "fetch-user" (dict "arglists" "([t])" "doc" "\"Find user based on login\"") "new-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"Create new user record\"") "register-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"create a unique user and store it in the user store\"") "reset-user-store!" (dict "arglists" "([])" "doc" "\"mainly for used in testing. Clears out all users.\"") "store-user" (dict "arglists" "([t])" "doc" "\"Store the given User and return it.\"") "user-store" (dict) "users" (dict "arglists" "([])" "doc" "\"Sequence of users\"") "valid-password?" (dict "arglists" "([candidate hashed])" "doc" "\"Verify that candidate password matches the hashed bcrypted password\""))) "clj-http.client" (dict "aliases" (dict "conn" "clj-http.conn-mgr" "core" "clj-http.core" "str" "clojure.string" "util" "clj-http.util") "interns" (dict "*current-middleware*" (dict "doc" "\"Available at any time to retrieve the middleware being used.\\n  Automatically bound when `with-middleware` is used.\"") "accept-encoding-value" (dict "arglists" "([accept-encoding])") "basic-auth-value" (dict "arglists" "([basic-auth])") "check-url!" (dict "arglists" "([url])") "client-error?" (dict "arglists" "([{:keys [status]}])") "coerce-clojure-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-content-type" (dict) "coerce-form-params" (dict) "coerce-form-urlencoded-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-json-body" (dict "arglists" "([{:keys [coerce]} {:keys [body status], :as resp} keyword? strict? & [charset]])") "coerce-response-body" (dict) "coerce-transit-body" (dict "arglists" "([{:keys [transit-opts], :as request} {:keys [body], :as resp} type])") "coerce-transit-form-params" (dict "arglists" "([type {:keys [form-params transit-opts]}])") "conflict?" (dict "arglists" "([{:keys [status]}])") "content-type-value" (dict "arglists" "([type])") "copy" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "crouton-enabled?" (dict) "decompress-body" (dict) "default-middleware" (dict "doc" "\"The default list of middleware clj-http uses for wrapping requests.\"") "delete" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "detect-charset" (dict "arglists" "([content-type])" "doc" "\"Given a charset header, detect the charset, returns UTF-8 if not found.\"") "dissoc-in" (dict "arglists" "([m [k & ks :as keys]])" "doc" "\"Dissociates an entry from a nested associative structure returning a new\\n  nested structure. keys is a sequence of keys. Any empty maps that result\\n  will not be present in the new structure.\"") "edn-enabled?" (dict) "follow-redirect" (dict "arglists" "([client {:keys [uri url scheme server-name server-port], :as req} {:keys [trace-redirects body], :as resp}])" "doc" "\"Attempts to follow the redirects from the \\\"location\\\" header, if no such\\n  header exists (bad server!), returns the response without following the\\n  request.\"") "form-decode" ...)) "clj-time.coerce" (dict "aliases" (dict "time-fmt" "clj-time.format") "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "ICoerce" (dict) "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" ...)) "clj-time.core" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" (dict "arglists" "([this])" "doc" "\"Returns the first day of the month\"") "floor" ...)) "clj-time.format" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "Mappable" (dict) "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" ...)) "clj-time.periodic" (dict "aliases" (dict "ct" "clj-time.core") "interns" (dict "periodic-seq" (dict "arglists" "([start period-like] [start end period-like])" "doc" "\"Returns a sequence of date-time values growing over specific period.\\n  The 2 argument function takes as input the starting value and the growing value,\\n  returning a lazy infinite sequence.\\n  The 3 argument function takes as input the starting value, the upper bound value,\\n  and the growing value, return a lazy sequence.\""))) "clojure.core.async" (dict "aliases" (dict "buffers" "clojure.core.async.impl.buffers" "channels" "clojure.core.async.impl.channels" "conc" "clojure.core.async.impl.concurrent" "core" "clojure.core" "dispatch" "clojure.core.async.impl.dispatch" "impl" "clojure.core.async.impl.protocols" "ioc" "clojure.core.async.impl.ioc-macros" "mutex" "clojure.core.async.impl.mutex" "timers" "clojure.core.async.impl.timers") "interns" (dict "<!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Must be called inside a (go ...) block. Will\\n  return nil if closed. Will park if nothing is available.\"") "<!!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Will return nil if closed. Will block\\n  if nothing is available.\"") ">!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Must be called\\n  inside a (go ...) block. Will park if no buffer space is available.\\n  Returns true unless port is already closed.\"") ">!!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Will block if no\\n  buffer space is available. Returns true unless port is already closed.\"") "Mix" (dict) "Mult" (dict) "Mux" (dict) "Pub" (dict) "admix" (dict "arglists" "([mix ch])" "doc" "\"Adds ch as an input to the mix\"") "admix*" (dict "arglists" "([m ch])") "alt!" (dict "arglists" "([& clauses])" "doc" "\"Makes a single choice between one of several channel operations,\\n  as if by alts!, returning the value of the result expr corresponding\\n  to the operation completed. Must be called inside a (go ...) block.\\n\\n  Each clause takes the form of:\\n\\n  channel-op[s] result-expr\\n\\n  where channel-ops is one of:\\n\\n  take-port - a single port to take\\n  [take-port | [put-port put-val] ...] - a vector of ports as per alts!\\n  :default | :priority - an option for alts!\\n\\n  and result-expr is either a list beginning with a vector, whereupon that\\n  vector will be treated as a binding for the [val port] return of the\\n  operation, else any other expression.\\n\\n  (alt!\\n    [c t] ([val ch] (foo ch val))\\n    x ([v] v)\\n    [[out val]] :wrote\\n    :default 42)\\n\\n  Each option may appear at most once. The choice and parking\\n  characteristics are those of alts!.\"" "macro" "true") "alt!!" (dict "arglists" "([& clauses])" "doc" "\"Like alt!, except as if by alts!!, will block until completed, and\\n  not intended for use in (go ...) blocks.\"" "macro" "true") "alt-flag" (dict "arglists" "([])") "alt-handler" (dict "arglists" "([flag cb])") "alts!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Completes at most one of several channel operations. Must be called\\n  inside a (go ...) block. ports is a vector of channel endpoints,\\n  which can be either a channel to take from or a vector of\\n  [channel-to-put-to val-to-put], in any combination. Takes will be\\n  made as if by <!, and puts will be made as if by >!. Unless\\n  the :priority option is true, if more than one port operation is\\n  ready a non-deterministic choice will be made. If no operation is\\n  ready and a :default value is supplied, [default-val :default] will\\n  be returned, otherwise alts! will park until the first operation to\\n  become ready completes. Returns [val port] of the completed\\n  operation, where val is the value taken for takes, and a\\n  boolean (true unless already closed, as per put!) for puts.\\n\\n  opts are passed as :key val ... Supported options:\\n\\n  :default val - the value to use if none of the operations are immediately ready\\n  :priority true - (default nil) when true, the operations will be tried in order.\\n\\n  Note: there is no guarantee that the port exps or val exprs will be\\n  used, nor in what order should they be, so they should not be\\n  depended upon for side effects.\"") "alts!!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Like alts!, except takes will be made as if by <!!, and puts will\\n  be made as if by >!!, will block until completed, and not intended\\n  for use in (go ...) blocks.\"") "bounded-count" (dict "arglists" "([n coll])" "doc" "\"Returns the smaller of n or the count of coll, without examining\\n  more than n items if coll is not counted\"") "buffer" (dict "arglists" "([n])" "doc" "\"Returns a fixed buffer of size n. When full, puts will block/park.\"") "chan" (dict "arglists" "([] [buf-or-n] [buf-or-n xform] [buf-or-n xform ex-handler])" "doc" "\"Creates a channel with an optional buffer, an optional transducer\\n  (like (map f), (filter p) etc or a composition thereof), and an\\n  optional exception-handler.  If buf-or-n is a number, will create\\n  and use a fixed buffer of that size. If a transducer is supplied a\\n  buffer must be specified. ex-handler must be a fn of one argument -\\n  if an exception occurs during transformation it will be called with\\n  the Throwable as an argument, and any non-nil return value will be\\n  placed in the channel.\"") "close!" (dict "arglists" "([chan])" "doc" "\"Closes a channel. The channel will no longer accept any puts (they\\n  will be ignored). Data in the channel remains available for taking, until\\n  exhausted, after which takes will return nil. If there are any\\n  pending takes, they will be dispatched with nil. Closing a closed\\n  channel is a no-op. Returns nil.\\n\\n  Logically closing happens after all puts have been delivered. Therefore, any\\n  blocked or parked puts will remain blocked/parked until a taker releases them.\"") "do-alt" (dict "arglists" "([alts clauses])") "do-alts" (dict "arglists" "([fret ports opts])" "doc" "\"returns derefable [val port] if immediate, nil if enqueued\"") "dropping-buffer" (dict "arglists" "([n])" "doc" "\"Returns a buffer of size n. When full, puts will complete but\\n  val will be dropped (no transfer).\"") "fhnop" (dict) "filter<" ...)) "clojure.data.json" (dict "aliases" (dict "pprint" "clojure.pprint") "interns" (dict "*bigdec*" (dict) "*escape-js-separators*" (dict) "*escape-slash*" (dict) "*escape-unicode*" (dict) "*key-fn*" (dict) "*value-fn*" (dict) "-read" (dict "arglists" "([stream eof-error? eof-value])") "-write" (dict "arglists" "([object out])" "doc" "\"Print object to PrintWriter out as JSON\"") "JSONWriter" (dict) "codepoint" (dict "arglists" "([c])" "macro" "true") "codepoint-case" (dict "arglists" "([e & clauses])" "macro" "true") "codepoint-clause" (dict "arglists" "([[test result]])") "default-value-fn" (dict "arglists" "([k v])") "default-write-key-fn" (dict "arglists" "([x])") "json-str" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write-str'.\\n\\n  Converts x to a JSON-formatted string.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn of \\\\uXXXX escapes of Unicode characters.\"") "pprint" (dict "arglists" "([x & options])" "doc" "\"Pretty-prints JSON representation of x to *out*. Options are the\\n  same as for write except :value-fn, which is not supported.\"") "pprint-array" (dict "arglists" "([s])") "pprint-dispatch" (dict "arglists" "([x])") "pprint-generic" (dict "arglists" "([x])") "pprint-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'pprint'.\\n\\n  Pretty-prints JSON representation of x to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "pprint-object" (dict "arglists" "([m])") "print-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write' to *out*.\\n\\n  Write JSON-formatted output to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "read" (dict "arglists" "([reader & options])" "doc" "\"Reads a single item of JSON data from a java.io.Reader. Options are\\n  key-value pairs, valid options are:\\n\\n     :eof-error? boolean\\n\\n        If true (default) will throw exception if the stream is empty.\\n\\n     :eof-value Object\\n\\n        Object to return if the stream is empty and eof-error? is\\n        false. Default is nil.\\n\\n     :bigdec boolean\\n\\n        If true use BigDecimal for decimal numbers instead of Double.\\n        Default is false.\\n\\n     :key-fn function\\n\\n        Single-argument function called on JSON property names; return\\n        value will replace the property names in the output. Default\\n        is clojure.core/identity, use clojure.core/keyword to get\\n        keyword properties.\\n\\n     :value-fn function\\n\\n        Function to transform values in maps (\\\"objects\\\" in JSON) in\\n        the output. For each JSON property, value-fn is called with\\n        two arguments: the property name (transformed by key-fn) and\\n        the value. The return value of value-fn will replace the value\\n        in the output. If value-fn returns itself, the property will\\n        be omitted from the output. The default value-fn returns the\\n        value unchanged. This option does not apply to non-map\\n        collections.\"") "read-array" (dict "arglists" "([stream])") "read-decimal" ...)) "clojure.java.jdbc" (dict "aliases" (dict "str" "clojure.string" "walk" "clojure.walk") "interns" (dict "Connectable" (dict) "IResultSetReadColumn" (dict "doc" "\"Protocol for reading objects from the java.sql.ResultSet. Default\\n   implementations (for Object and nil) return the argument, and the\\n   Boolean implementation ensures a canonicalized true/false value,\\n   but it can be extended to provide custom behavior for special types.\"") "ISQLParameter" (dict "doc" "\"Protocol for setting SQL parameters in statement objects, which\\n   can convert from Clojure values. The default implementation just\\n   delegates the conversion to ISQLValue's sql-value conversion and\\n   uses .setObject on the parameter. It can be extended to use other\\n   methods of PreparedStatement to convert and set parameter values.\"") "ISQLValue" (dict "doc" "\"Protocol for creating SQL values from Clojure values. Default\\n   implementations (for Object and nil) just return the argument,\\n   but it can be extended to provide custom behavior to support\\n   exotic types supported by different databases.\"") "add-connection" (dict "arglists" "([db connection])") "as-properties" (dict "arglists" "([m])" "doc" "\"Convert any seq of pairs to a java.utils.Properties instance.\\n   Uses as-sql-name to convert both keys and values into strings.\"") "as-sql-name" (dict "arglists" "([f] [f x])" "doc" "\"Given a naming strategy function and a keyword or string, return\\n   a string per that naming strategy.\\n   A name of the form x.y is treated as multiple names, x, y, etc,\\n   and each are turned into strings via the naming strategy and then\\n   joined back together so x.y might become `x`.`y` if the naming\\n   strategy quotes identifiers with `.\"") "classnames" (dict "doc" "\"Map of classnames to subprotocols\"") "col-str" (dict "arglists" "([col entities])" "doc" "\"Transform a column spec to an entity name for SQL. The column spec may be a\\n  string, a keyword or a map with a single pair - column name and alias.\"") "create-table-ddl" (dict "arglists" "([table specs] [table specs opts])" "doc" "\"Given a table name and a vector of column specs return the DDL string for\\n  creating that table. An options map may be provided that can contain:\\n  :table-spec -- a string that is appended to the DDL -- and/or\\n  :entities -- a function to specify how column names are transformed.\"") "db-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or throws if there is none)\"") "db-do-commands" (dict "arglists" "([db sql-commands] [db transaction? sql-commands])" "doc" "\"Executes SQL commands on the specified database connection. Wraps the commands\\n  in a transaction if transaction? is true. transaction? can be ommitted and it\\n  defaults to true. Accepts a single SQL command (string) or a vector of them.\\n  Uses executeBatch. This may affect what SQL you can run via db-do-commands.\"") "db-do-execute-prepared-return-keys" (dict "arglists" "([db stmt param-group transaction?])" "doc" "\"Executes a PreparedStatement, optionally in a transaction, and (attempts to)\\n  return any generated keys.\"") "db-do-execute-prepared-statement" (dict "arglists" "([db stmt param-groups transaction?])" "doc" "\"Execute a PreparedStatement, optionally in a transaction.\"") "db-do-prepared" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. Each param-group is a seq of values for all of\\n  the parameters. transaction? can be omitted and defaults to true.\\n  The sql parameter can either be a SQL string or a PreparedStatement.\\n  Return a seq of update counts (one count for each param-group).\"") "db-do-prepared-return-keys" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. The param-group is a seq of values for all of\\n  the parameters. transaction? can be ommitted and will default to true.\\n  Return the generated keys for the (single) update/insert.\\n  A PreparedStatement may be passed in, instead of a SQL string, in which\\n  case :return-keys MUST BE SET on that PreparedStatement!\"") "db-find-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or nil if there is none)\"") "db-is-rollback-only" (dict "arglists" "([db])" "doc" "\"Returns true if the outermost transaction will rollback rather than\\n  commit when complete\"") "db-query-with-resultset" (dict "arglists" "([db sql-params func] [db sql-params func opts])" "doc" "\"Executes a query, then evaluates func passing in the raw ResultSet as an\\n   argument. The second argument is a vector containing either:\\n    [sql & params] - a SQL query, followed by any parameters it needs\\n    [stmt & params] - a PreparedStatement, followed by any parameters it needs\\n                      (the PreparedStatement already contains the SQL query)\\n  The opts map is passed to prepare-statement.\\n  Uses executeQuery. This may affect what SQL you can run via query.\"") "db-set-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will rollback rather than\\n  commit when complete\"") "db-transaction*" (dict "arglists" "([db func] [db func {:keys [isolation read-only?], :as opts}])" "doc" "\"Evaluates func as a transaction on the open database connection. Any\\n  nested transactions are absorbed into the outermost transaction. By\\n  default, all database updates are committed together as a group after\\n  evaluating the outermost body, or rolled back on any uncaught\\n  exception. If rollback is set within scope of the outermost transaction,\\n  the entire transaction will be rolled back rather than committed when\\n  complete.\\n  The isolation option may be :none, :read-committed, :read-uncommitted,\\n  :repeatable-read, or :serializable. Note that not all databases support\\n  all of those isolation levels, and may either throw an exception or\\n  substitute another isolation level.\\n  The read-only? option puts the transaction in readonly mode (if supported).\"") "db-unset-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will not rollback when complete\"") "delete!" (dict "arglists" "([db table where-clause] [db table where-clause {:keys [entities transaction?], :or {entities identity, transaction? true}}])" "doc" "\"Given a database connection, a table name and a where clause of columns to match,\\n  perform a delete. The options may specify how to transform column names in the\\n  map (default 'as-is') and whether to run the delete in a transaction (default true).\\n  Example:\\n    (delete! db :person [\\\"zip = ?\\\" 94546])\\n  is equivalent to:\\n    (execute! db [\\\"DELETE FROM person WHERE zip = ?\\\" 94546])\"") "delete-sql" (dict "arglists" "([table [where & params] entities])" "doc" "\"Given a table name, a where class and its parameters and an optional entities spec,\\n  return a vector of the SQL for that delete operation followed by its parameters. The\\n  entities spec (default 'as-is') specifies how to transform column names.\"") "direction" ...)) "clojure.pprint" (dict "aliases" (dict) "interns" (dict "*code-table*" (dict) "*current-length*" (dict) "*current-level*" (dict) "*default-page-width*" (dict) "*format-str*" (dict) "*print-base*" (dict "doc" "\"The base to use for printing integers and rationals.\"") "*print-circle*" (dict "doc" "\"Mark circular structures (N.B. This is not yet used)\"") "*print-lines*" (dict "doc" "\"Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)\"") "*print-miser-width*" (dict "doc" "\"The column at which to enter miser style. Depending on the dispatch table, \\nmiser style add newlines in more places to try to keep lines short allowing for further \\nlevels of nesting.\"") "*print-pprint-dispatch*" (dict "doc" "\"The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch\\nto modify.\"") "*print-pretty*" (dict "doc" "\"Bind to true if you want write to use pretty printing\"") "*print-radix*" (dict "doc" "\"Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, \\nor 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the \\nradix specifier is in the form #XXr where XX is the decimal value of *print-base* \"") "*print-right-margin*" (dict "doc" "\"Pretty printing will try to avoid anything going beyond this column.\\nSet it to nil to have pprint let the line be arbitrarily long. This will ignore all \\nnon-mandatory newlines.\"") "*print-shared*" (dict "doc" "\"Mark repeated structures rather than repeat them (N.B. This is not yet used)\"") "*print-suppress-namespaces*" (dict "doc" "\"Don't print namespaces with symbols. This is particularly useful when \\npretty printing the results of macro expansions\"") "*symbol-map*" (dict) "abort?" (dict "arglists" "([context])") "absolute-reposition" (dict "arglists" "([navigator position])") "absolute-tabulation" (dict "arglists" "([params navigator offsets])") "add-core-ns" (dict "arglists" "([amap])") "add-english-scales" (dict "arglists" "([parts offset])" "doc" "\"Take a sequence of parts, add scale numbers (e.g., million) and combine into a string\\noffset is a factor of 10^3 to multiply by\"") "add-to-buffer" (dict "arglists" "([this token])") "ancestor?" (dict "arglists" "([parent child])") "arg-navigator" (dict) "base-str" ...)) "clojure.set" (dict "aliases" (dict) "interns" (dict "bubble-max-key" (dict "arglists" "([k coll])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "index" (dict "arglists" "([xrel ks])" "doc" "\"Returns a map of the distinct values of ks in the xrel mapped to a\\n  set of the maps in xrel with the corresponding values of ks.\"") "intersection" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the intersection of the input sets\"") "join" (dict "arglists" "([xrel yrel] [xrel yrel km])" "doc" "\"When passed 2 rels, returns the rel corresponding to the natural\\n  join. When passed an additional keymap, joins on the corresponding\\n  keys.\"") "map-invert" (dict "arglists" "([m])" "doc" "\"Returns the map with the vals mapped to the keys.\"") "project" (dict "arglists" "([xrel ks])" "doc" "\"Returns a rel of the elements of xrel with only the keys in ks\"") "rename" (dict "arglists" "([xrel kmap])" "doc" "\"Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap\"") "rename-keys" (dict "arglists" "([map kmap])" "doc" "\"Returns the map with the keys in kmap renamed to the vals in kmap\"") "select" (dict "arglists" "([pred xset])" "doc" "\"Returns a set of the elements for which pred is true\"") "subset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a subset of set2?\"") "superset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a superset of set2?\"") "union" (dict "arglists" "([] [s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the union of the input sets\""))) "clojure.string" (dict "aliases" (dict) "interns" (dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...)) "clojure.walk" (dict "aliases" (dict) "interns" (dict "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\""))) "clojure.walk2" (dict "aliases" (dict) "interns" (dict "Walkable" (dict) "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form. For\\n  development use only: This function does not perfectly emulate\\n  macroexpansion by the Clojure compiler because it doesn't understand\\n  special forms like 'let'.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "walkt" (dict "arglists" "([coll f])" "doc" "\"If coll is a collection, applies f to each element of the collection\\n  and returns a collection of the results, of the same type and order\\n  as coll. If coll is not a collection, returns it unchanged. \\\"Same\\n  type\\\" means a type with the same behavior. For example, a hash-map\\n  may be returned as an array-map, but a a sorted-map will be returned\\n  as a sorted-map with the same comparator.\"") "walkt-default" (dict "arglists" "([coll f])") "walkt-transient" (dict "arglists" "([coll f])"))) "clostache.parser" (dict "aliases" (dict "io" "clojure.java.io" "str" "clojure.string") "interns" (dict "->Section" (dict "arglists" "([name body start end inverted])" "doc" "\"Positional factory function for class clostache.parser.Section.\"") "convert-path" (dict "arglists" "([tag open-delim close-delim data])" "doc" "\"Convert a tag with a dotted name to nested sections, using the\\n  supplied delimiters to access the value.\"") "convert-paths" (dict "arglists" "([template data])" "doc" "\"Converts tags with dotted tag names to nested sections.\"") "create-partial-replacements" (dict "arglists" "([template partials])" "doc" "\"Creates pairs of partial replacements.\"") "escape-html" (dict "arglists" "([string])" "doc" "\"Replaces angle brackets with the respective HTML entities.\"") "escape-regex" (dict "arglists" "([regex])" "doc" "\"Escapes characters that have special meaning in regular expressions.\"") "extract-section" (dict "arglists" "([template])" "doc" "\"Extracts the outer section from the template.\"") "find-section-end-tag" (dict "arglists" "([template index level])" "doc" "\"Find the matching end tag for a section at the specified level,\\n   starting to search at index.\"") "find-section-start-tag" (dict "arglists" "([template index])" "doc" "\"Find the next section start tag, starting to search at index.\"") "include-partials" (dict "arglists" "([template partials])" "doc" "\"Include partials within the template.\"") "indent-partial" (dict "arglists" "([partial indent])" "doc" "\"Indent all lines of the partial by indent.\"") "join-standalone-delimiter-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) delimiter tags.\"") "join-standalone-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) section/partials\\n   tags.\"") "map->Section" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class clostache.parser.Section, taking a map of keywords to field values.\"") "map-str" (dict "arglists" "([f coll])" "doc" "\"Apply f to each element of coll, concatenate all results into a\\n  String.\"") "next-index" (dict "arglists" "([section regex] [section regex index])" "doc" "\"Return the next index of the supplied regex.\"") "path-data" (dict "arglists" "([elements data])" "doc" "\"Extract the data for the supplied path.\"") "preprocess" (dict "arglists" "([template data partials])" "doc" "\"Preprocesses template and data (e.g. removing comments).\"") "process-set-delimiters" (dict "arglists" "([template data])" "doc" "\"Replaces custom set delimiters with mustaches.\"") "regex-chars" (dict) "remove-comments" (dict "arglists" "([template])" "doc" "\"Removes comments from the template.\"") "render" (dict "arglists" "([template] [template data] [template data partials])" "doc" "\"Renders the template with the data and, if supplied, partials.\"") "render-resource" (dict "arglists" "([path] [path data] [path data partials])" "doc" "\"Renders a resource located on the classpath\"") "render-section" (dict "arglists" "([section data partials])") "render-template" ...)) "crypto.random" (dict "aliases" (dict "string" "clojure.string") "interns" (dict "base32" (dict "arglists" "([size])" "doc" "\"Return a random base32 string of the specified size in bytes.\"") "base64" (dict "arglists" "([size])" "doc" "\"Return a random base64 string of the specified size in bytes.\"") "bytes" (dict "arglists" "([size])" "doc" "\"Returns a random byte array of the specified size.\"") "hex" (dict "arglists" "([size])" "doc" "\"Return a random hex string of the specified size in bytes.\"") "url-part" (dict "arglists" "([size])" "doc" "\"Return a random string suitable for being inserted into URLs. The size\\n  denotes the number of bytes to generate.\""))) "hugsql.core" (dict "aliases" (dict "adapter" "hugsql.adapter" "edn" "clojure.tools.reader.edn" "io" "clojure.java.io" "parameters" "hugsql.parameters" "parser" "hugsql.parser" "string" "clojure.string") "interns" (dict "adapter" (dict) "command-sym" (dict "arglists" "([hdr])") "compile-exprs" (dict "arglists" "([pdef])" "doc" "\"Compile (def) all expressions in a parsed def\"") "db-fn" (dict "arglists" "([sql] [sql command] [sql command result] [sql command result options])" "doc" "\"Given an sql string and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn*" (dict "arglists" "([psql] [psql command] [psql command result] [psql command result options])" "doc" "\"Given parsed sql and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn-map" (dict "arglists" "([pdef options])" "doc" "\"Hashmap of db fn from a parsed def\\n   with the form:\\n   {:fn-name {:meta {:doc \\\"doc string\\\"}\\n              :fn <anon-db-fn>}\"") "db-run" (dict "arglists" "([db sql] [db sql param-data] [db sql param-data command] [db sql param-data command result] [db sql param-data command result options & command-options])" "doc" "\"Given a database spec/connection, sql string,\\n   parameter data, and optional command, result,\\n   and options, run the sql statement\"") "def-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   :quoting options for identifiers are:\\n     :ansi double-quotes: \\\"identifier\\\"\\n     :mysql backticks: `identifier`\\n     :mssql square brackets: [identifier]\\n     :off no quoting (default)\\n\\n   Identifiers containing a period/dot . are split, quoted separately,\\n   and then rejoined. This supports myschema.mytable conventions.\\n\\n   :quoting can be overridden as an option in the calls to functions\\n   created by def-db-fns.\\n\\n   :adapter specifies the HugSQL adapter to use for all defined\\n   functions. The default adapter used is\\n   (hugsql.adapter.clojure-java-jdbc/hugsql-adapter-clojure-java-jdbc)\\n   when :adapter is not given.\\n\\n   See also hugsql.core/set-adapter! to set adapter for all def-db-fns\\n   calls.  Also, :adapter can be specified for individual function\\n   calls (overriding set-adapter! and the :adapter option here).\"" "macro" "true") "def-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "def-expr" (dict "arglists" "([expr] [expr require-str])") "def-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "def-sqlvec-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns-from-string s options?)\\n\\n   where:\\n    - s is a HugSQL-flavored sql string\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "default-db-options" (dict) "default-sqlvec-options" (dict) "expr-name" (dict "arglists" "([expr])") "expr-pass" (dict "arglists" "([sql-template params options])" "doc" "\"Takes an sql template (from hugsql parser) and evaluates the\\n  Clojure expressions resulting in returning an sql template\\n  containing only sql strings and hashmap parameters\"") "get-adapter" (dict "arglists" "([])" "doc" "\"Get an adapter.  Sets default\\n   hugsql.adapter.clojure-java-jdbc\\n   adapter if no adapter is set.\"") "hugsql-command-fn" (dict) "hugsql-result-fn" (dict) "intern-db-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the db fn from a parsed def\"") "intern-sqlvec-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the sqlvec fn from a parsed def\"") "map-of-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n  Usage:\\n\\n   (map-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "map-of-sqlvec-fns-from-string" ...)) "io.aviso.rook" (dict "aliases" (dict "dispatcher" "io.aviso.rook.dispatcher" "medley" "medley.core" "p" "potemkin" "swagger" "io.aviso.rook.swagger" "t" "io.aviso.tracker") "interns" (dict "compose-middleware" (dict "arglists" "([& middlewares])" "doc" "\"Assembles multiple endpoint middleware forms into a single endpoint middleware. Each middleware form\\n  is either a list or a single form, that will be wrapped as a list.\\n\\n  The list is modified so that the first two values passed in are the previous handler and the metadata (associated\\n  with the endpoint function).\\n\\n  The form should evaluate to a new handler, or the old handler. As a convienience, the form may\\n  evaluate to nil, which will keep the original handler passed in.\\n\\n  Returns a function that accepts a handler and middleware and invokes each middleware form in turn, returning\\n  a final handler function.\\n\\n  This is patterned on Clojure's -> threading macro, with some significant differences.\"" "macro" "true") "consume" (dict "arglists" "([coll bindings & body])" "doc" "\"Consume is used to break apart a collection into individual terms.\\n\\n  The format is:\\n\\n      (consume coll [symbol predicate arity ...] body)\\n\\n  The symbol is assigned a value by extracting zero or more values from the collection that\\n  match the predicate. The predicate is passed a single element from the\\n  collection and should return a truth value.\\n\\n  The arity is a keyword that identifies how many values are taken\\n  from the collection.\\n\\n  :one\\n  : The first value in the collection must match the predicate, or an exception is thrown.\\n    The value is assigned to the symbol.  The literal value 1 may be used instead of :one.\\n\\n  :?\\n  : Matches 0 or 1 values from the collection. If the first value does not match the predicate,\\n    then nil is assigned to the symbol.\\n\\n  :*\\n  : Zero or more values from the collection are assigned to the symbol. The symbol may be assigned\\n    an empty collection.\\n\\n  :+\\n  : Matches one or more values; an exception is thrown if there are no matches.\\n\\n  The symbol/pred/arity triplet can be followed by additional triplets.\\n\\n  Although the above description discusses triplets, there are two special predicate values\\n  that are used as just a pair (symbol followed by special predicate), with no arity.\\n\\n  :&\\n  : Used to indicate consumption of all remaining values, if any, from the collection.\\n    It is not followed by an arity, and must be the final term in the bindings vector.\\n\\n  :+\\n  : Used to consume a single value always (throwing an exception if the collection is\\n    empty).\\n\\n  consume expands into a let form, so the symbol in each triplet may be a destructuring form.\\n\\n  As an example, a function that expects an optional map followed by at least\\n  one string, followed by any number of vectors:\\n\\n\\n      (defn example\\n        {:arglists '([options strings... & vectors] [strings... & vectors])}\\n        [& args]\\n        (consume args\\n          [options map? :?       ; nil or a map\\n           strings string? :+    ; seq of strings, at least one\\n           vectors :&]           ; remaining arguments, may be empty\\n           ;; Use options, strings, vectors here\\n           ...))\\n  \"" "macro" "true") "find-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an optional injected value from the request, returning nil if the value does not exist.\"") "get-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an injected value stored in the request. Throws an exception if the value is falsey.\"") "inject" (dict "arglists" "([request key value])" "doc" "\"Merges a single keyword key and value into the map of injectable argument values store in the request.\\n  This is associated with the :injection argument metadata.\"") "inject*" (dict "arglists" "([request injection-map])" "doc" "\"Merges the provided map of injectable argument values into the request. Keys should be keywords\\n  (that will match against function argument symbols, converted to keywords).\"") "namespace-handler" (dict "arglists" "([options & ns-specs] [& ns-specs])" "doc" "\"Examines the given namespaces and produces either a Ring handler or\\n  an asynchronous Ring handler.\\n\\n  Options can be provided as a leading map (which is optional).\\n\\n  The individual namespaces are specified as vectors of the following\\n  shape:\\n\\n      [context? ns-sym argument-resolvers? middleware? nested...?]\\n\\n  The optional fragments are interpreted as below:\\n\\n  context?\\n  : A context (a string, or a vector of strings and/or keywords) to be prepended to paths for all entries\\n  emitted for this namespace.\\n\\n  ns-sym\\n  : The symbol for the namespace that is to be mapped.\\n  : This is the only required value in the namespace specification.\\n\\n  argument-resolvers?\\n  : A map of argument resolvers that apply to the namespace, and to any child namespaces.\\n\\n  middleware?\\n  : Middleware to be applied to terminal handlers found in this\\n  namespace.\\n\\n  nested...?\\n  : Defines child namespaces, each its own recursive namespace specification.\\n  Child namespaces inherit the context, argument resolvers, and middleware\\n  of the containing namespace.\\n\\n  Supported options and their default values:\\n\\n  :arg-resolvers\\n  : Map of symbol to (keyword or function of request) or keyword\\n    to (function of symbol returning function of request). Entries of\\n    the former provide argument resolvers to be used when resolving\\n    arguments named by the given symbol; in the keyword case, a known\\n    resolver factory will be used.\\n  : Normally, the provided map is merged into the map inherited from\\n    the containing namespace (or elsewhere), but this can be controlled\\n    using metadata on the map.\\n  : Tag with {:replace true} to\\n    exclude inherited resolvers and resolver factories; tag with\\n    {:replace-resolvers true} or {:replace-factories true} to leave\\n    out default resolvers or resolver factories, respectively.\\n\\n  :context\\n  : _Default: []_\\n  : A root context that all namespaces are placed under, for example [\\\"api\\\"].\\n\\n  :default-middleware\\n  : _Default: [[default-namespace-middleware]]_\\n  : Default endpoint middleware applied to the basic handler for\\n    each endpoint function (the basic handler resolver arguments and passes\\n    them to the endpoint function).\\n    The default leaves the basic handler unchanged.\\n\\n  :swagger-options\\n  : Options to be passed to [[construct-swagger-object]], that control how the Swagger description is composed and\\n    customized.\\n    Swagger support is only enabled when :swagger-options is non-nil.\\n\\n  Example call:\\n\\n       (namespace-handler\\n         {:context            [\\\"api\\\"]\\n          :swagger-options    swagger/default-swagger-options\\n          :default-middleware custom-middleware\\n          :arg-resolvers      {'if-unmodified-since :header\\n                               'if-modified-since   :header}}\\n         ;; foo & bar use custom-middleware:\\n         [\\\"hotels\\\" 'org.example.resources.hotels\\n           [[:hotel-id \\\"rooms\\\"] 'org.example.resources.rooms]]\\n         [\\\"bars\\\" 'org.example.resources.bars]\\n         ;; taxis has special requirements:\\n         [\\\"taxis\\\" 'org.example.resources.taxis\\n           {:dispatcher dispatcher-resolver-factory}\\n           taxi-middleware]).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "resolve-argument-value" (dict "arglists" "([request argument-meta argument-symbol])" "doc" "\"Resolves an argument, as if it were an argument to an endpoint function.\\n\\n  request\\n  : The Ring request map, as passed through middleware and to the endpoint.\\n\\n  argument-meta\\n  : A map of metadata about the symbol, or a single keyword. A keyword is converted\\n    to a map (of the keyword, to true).\\n\\n  argument-symbol\\n  : A symbol identifying the name of the parameter. This is sometimes needed to construct\\n    the argument resolver function.\\n\\n  Throws an exception if no (single) argument resolver can be identified.\"") "wrap-with-injection" (dict "arglists" "([handler key value])" "doc" "\"Wraps a request handler with an injection of the key and value.\"") "wrap-with-injections" (dict "arglists" "([handler injections])" "doc" "\"Wraps a request handler with injections by merging in a map.\"") "wrap-with-standard-middleware" (dict "arglists" "([handler])" "doc" "\"The standard middleware that Rook expects to be present before it is passed the Ring request.\""))) "io.aviso.rook.server" (dict "aliases" (dict "io" "clojure.java.io" "l" "clojure.tools.logging" "medley" "medley.core" "rook" "io.aviso.rook" "str" "clojure.string" "t" "io.aviso.tracker" "utils" "io.aviso.rook.utils") "interns" (dict "cond-let" (dict "arglists" "([& forms])" "doc" "\"A merging of cond and let.  Each term is either a vector\\n  (in which case, it acts like let) or a condition expression followed by the value\\n  for that expression. An empty cond-let returns nil.\\n\\n  cond-let makes it possible to create readable code that doesn't end up nesting\\n  ;endlessly.\\n\\n  A typical example is where several steps must occur, perhaps reading data from\\n  an external datastore and making a few consistency checks:\\n\\n      (defn apply-payment [db-conn order-id user-id payment-info]\\n        (cond-let\\n          [order (find-order-by-id db-conn order-id)]\\n\\n          (nil? order)\\n          not-found-response\\n\\n          (not (owned-by? order user-id))\\n          forbidden-response\\n\\n          [existing-payment (find-payment db-conn (:payment-id order))]\\n\\n          (some? existing-payment)\\n          already-payed-response\\n\\n          :else\\n          (do\\n            (attach-payment db-conn order payment-info)\\n\\n            updated-response)))\"" "macro" "true") "construct-handler" (dict "arglists" "([{:keys [reload log debug track standard exceptions lazy]} creator & creator-args])" "doc" "\"Constructs a root handler using a creator function.  Normally, the creator function\\n  is invoked immediately, and returns a Ring handler function. However, during development,\\n  to take advantage of code reloading, the creator will be invoked on each incoming request.\\n\\n  To fully take advantage of REPL oriented development, you should pass the Var containing\\n  the creator function, e.g. `#'create-app-handler`.\\n\\n  The optional creator-args are additional arguments to be passed to the creator function;\\n  these are usually configuration data or dependencies.\\n\\n  The options map contains several flags:\\n\\n  :reload\\n  : enables the above-described reloading of the handler.\\n\\n  :lazy\\n  : if true (and :reload is false) then the handler is not created until first needed, rather\\n    then immediately on invoking this function.\\n\\n  :debug\\n  : enables logging (at debug level) of each incoming request via [[wrap-debug-request]]\\n    and [[wrap-debug-response]]\\n\\n  :log\\n  : enables logging of a summary of each incoming request (at info level) via [[wrap-log-request]].\\n\\n  :track\\n  : enables tracking a summary of each incoming request via [[wrap-track-request]].\\n\\n  :standard\\n  : Enables the standard Rook middleware, (see [[wrap-with-standard-middleware]]).\\n\\n  :exceptions\\n  : Enables [[wrap-with-exception-catching]] to catch and report exceptions.\\n\\n  The extra middleware is added around the root handler (or the\\n  reloading handler that creates the root handler).\"") "format-binary" (dict "arglists" "([data & options])" "doc" "\"Formats the data using [[write-binary]] and returns the result as a string.\"") "format-bytes" (dict "arglists" "([label byte-array])") "lazy-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created lazily on first access.\"") "log-request-and-body" (dict "arglists" "([request body-array])") "log-response" (dict "arglists" "([response])" "doc" "\"Logs the response at debug level (if enabled) with nice formatting; returns a new response (since reading\\n  an InputStream body is destructive).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "read-bytes" (dict "arglists" "([stream length])") "reloading-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created fresh on each request;\\n  this is used when developing the application as it supports re-loading of code in a REPL without having to\\n  restart the embedded Jetty instance.\"") "to-message" (dict "arglists" "([t])" "doc" "\"Converts an exception to a message. Normally, this is the message property of the exception, but if\\n  that's blank, the fully qualified class name of the exception is used instead.\"") "wrap-creator" (dict "arglists" "([creator creator-args])" "doc" "\"Wraps a creator and arguments as a function of no arguments. If the creator fails, then\\n  the error is logged and a handler that always responds with a 500 status is returned.\"") "wrap-debug-request" (dict "arglists" "([handler])" "doc" "\"Logs a pretty-printed representation of each incoming request, at level debug. This includes output\\n  of the body's content in ASCII and hex; this means that the entire body (if present) may be consumed\\n  and stored in memory, and replaced with a new InputStream downstream (when debugging is enabled).\"") "wrap-debug-response" (dict "arglists" "([handler])" "doc" "\"Used to log the response sent back to the client at debug level.\"") "wrap-log-request" (dict "arglists" "([handler])" "doc" "\"Logs incoming requests (as info), identifying method and URI.\"") "wrap-track-request" (dict "arglists" "([handler])" "doc" "\"An alternative to [[wrap-log-request]]; adds tracking with a label via [[summarize-request]].\"") "wrap-with-exception-catching" (dict "arglists" "([handler])" "doc" "\"A simple exception catching and reporting wrapper.\\n\\n   Establishes a tracking checkpoint (so it works very well with [[wrap-track-request]].\\n\\n   Exceptions are converted to 500 responses in the standard [[failure-response]] format.\""))) "json-window.core" ...) "id" "4" "repl-type" "clj" "session" "158b7cdb-12a9-4f87-8c96-8f6940cad593" "status" ("state")) "green")
  nrepl-log-message((dict "changed-namespaces" (dict "G__42156" (dict "aliases" (dict) "interns" (dict)) "aggregate.core" (dict "aliases" (dict "jdbc" "clojure.java.jdbc" "p" "parsargs.core") "interns" (dict "->1" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :one> relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "->mn" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many> relationship.\\n  Available options:\\n  :query-fn         A function returning records by a foreign key.\\n  :update-links-fn  A function for updating link table records.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to false.\"") "->n" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :query-fn         A function returning records by a foreign key.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "default-fk" (dict "arglists" "([entity-kw])" "doc" "\"Returns a keyword that has the suffix '_id'.\"") "default-link-tablename" (dict "arglists" "([a-entity-kw b-entity-kw])" "doc" "\"Takes two tablenames and joins them with '_' and returns the result as keyword.\"") "delete!" (dict "arglists" "([er-config db-spec m] [er-config db-spec entity-kw m-or-id])" "doc" "\"Removes an aggregate datastructure from the database.\\n  Returns the number of deleted records.\"") "delete-dependants!" (dict "arglists" "([er-config db-spec id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw update-links-fn owned?]}]])" "doc" "\"Deletes all records that m contains, and that point by foreign key to m.\\n  Returns the number of deleted records.\"") "delete-prerequisite!" (dict "arglists" "([er-config db-spec m [relation-kw {:keys [relation-type entity-kw fk-kw owned?]}]])" "doc" "\"Deletes a record that m points to by a foreign key.\\n  Returns the number of deleted records or nil.\"") "dissoc-ks" (dict "arglists" "([m ks])" "doc" "\"Remove keys in ks from m.\"") "entity" (dict "arglists" "([& args])" "doc" "\"Returns an entity-spec from an entity keyword, an optional\\n  options-map and an arbitrary number of relation-specs, i.e.\\n      (agg/entity entity-kw options-map? relations)\\n  Available options:\\n  :read-fn       A function (fn [db-spec id]) returning the\\n                 record with primary key value id as a map.\\n  :insert-fn     A function (fn [db-spec row-map]) that inserts\\n                 the row-map as record, and returns the row-map\\n                 containing the new primary key value.\\n  :update-fn     A function (fn [db-spec set-map]) that updates\\n                 the record identified by the primary key value\\n                 within set-map with the values of set-map.\\n  :delete-fn     A function (fn [db-spec id]) that deletes the\\n                 record identified by the primary key value.\\n  :id-kw         The keyword to be used to get/assoc the primary\\n                 key value. It is also used as primary key\\n                 column name in default DB access functions.\"") "entity-parser" (dict) "entityspec?" (dict "arglists" "([x])" "doc" "\"Returns true if x is a vector containing a keyword as first and a\\n  map as second item\"") "er-config-parser" (dict) "extract-id" (dict "arglists" "([id-kw insert-result])" "doc" "\"Extracts id value from results like ({:scope_identity() 2}) or ({:id 2, ...}).\"") "keep-ks" (dict "arglists" "([m ks])" "doc" "\"Removes all but ks keys from map m.\"") "load" (dict "arglists" "([er-config db-spec entity-kw id] [er-config db-spec m])" "doc" "\"Loads an aggregate by `id`. The `entity-kw` denotes the aggregate root.\\n  Returns a map containing the entity-kw in ::entity and all data, or\\n  nil if the entity-kw is unknown or the record does not exist.\"") "load-relation" (dict "arglists" "([er-config db-spec visited id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw query-fn]}]])" "doc" "\"Loads more data according to the specified relation.\"") "load-relations" (dict "arglists" "([er-config db-spec visited m])") "log" (dict "arglists" "([& xs])") "make-delete-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns a delete function [db-spec id -> (Seq id)] for a specific\\n  table, which deletes the record id points to. It returns the number\\n  of deleted records (usually 1), or nil if none was deleted.\\n  The tablename may be passed as string or keyword.\"") "make-entity-options" (dict "arglists" "([tablename] [tablename id-kw])" "doc" "\"Returns a map containing all four default JDBC based implementations\\n  for read, insert, update and delete.\"") "make-er-config" (dict "arglists" "([& args])" "doc" "\"Creates a er-config map from an optional options-map and an\\n  arbitrary number of entity-specs, i.e.\\n      (agg/make-er-config options-map? entities)\\n  Available options:\\n  :read-fn-factory          A function (fn [tablename]) returning the\\n                            default read function.\\n  :insert-fn-factory        A function (fn [tablename]) returning the\\n                            default insert function.\\n  :update-fn-factory        A function (fn [tablename]) returning the\\n                            default update function.\\n  :delete-fn-factory        A function (fn [tablename]) returning the\\n                            default delete function.\\n  :query-<many-fn-factory   A function (fn [tablename fk-kw]) returning\\n                            the default query-for-many function using\\n                            one foreign key.\\n  :query-<many>-fn-factory  A function (fn [tablename linktablename fk-a fk-b])\\n                            returning the default query-for-many function\\n                            that uses a linktable.\\n  :update-links-fn-factory  A function (fn [linktablename fk-a fk-b])\\n                            returning the default function to update\\n                            link tables.\\n  :id-kw                    A keyword that is taken as default primary\\n                            key column name.\\n  :persisted-pred-fn        A predicate (fn [db-spec entity-kw id-kw row-map])\\n                            that returns true if the given row-map is already\\n                            present in DB.\"") "make-insert-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns an insert function [db-spec row-map -> row-map] for a specific table.\\n  It returns the record, possibly augmented with the generated id in\\n  an :id slot. The tablename may be passed as string or keyword.\"") "make-query-<many-fn" (dict "arglists" "([tablename fk-kw])" "doc" "\"Returns a finder function [db-spec id -> (Seq Map)] for a specific\\n  table, that returns -- as sequence of maps -- all records that have\\n  id as value of the foreign key field denoted by fk-kw.\\n  Assumes a simple n to 1 relationship.\"") "make-query-<many>-fn" ...)) "buddy.hashers" (dict "aliases" (dict "bytes" "buddy.core.bytes" "codecs" "buddy.core.codecs" "hash" "buddy.core.hash" "nonce" "buddy.core.nonce" "scrypt" "clojurewerkz.scrypt.core" "str" "clojure.string") "interns" (dict "+iterations+" (dict) "check" (dict "arglists" "([attempt encrypted] [attempt encrypted {:keys [limit setter prefered]}])" "doc" "\"Check if a unencrypted password matches\\n  with another encrypted password.\"") "check-password" (dict "doc" "\"Password verification implementation.\"") "derive" (dict "arglists" "([password] [password options])" "doc" "\"Encrypts a raw string password.\"") "derive-password" (dict "doc" "\"Derive key depending on algorithm.\"") "derive-password-for-legacy-pbkdf2+sha256" (dict "arglists" "([{:keys [alg password salt saltsize iterations]}])") "dispatch" (dict "arglists" "([opts & args])") "encrypt" (dict "doc" "\"Backward compatibility alias for `derive`.\"") "format-password" (dict "doc" "\"Format password depending on algorithm.\"") "must-update?" (dict "doc" "\"Check if the current password configuration\\n  is succeptible to be updatable.\"") "parse-password" (dict "doc" "\"Parse password from string to parts.\""))) "cemerick.url" (dict "aliases" (dict "pathetic" "pathetic.core" "string" "clojure.string") "interns" (dict "->URL" (dict "arglists" "([protocol username password host port path query anchor])" "doc" "\"Positional factory function for class cemerick.url.URL.\"") "map->URL" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class cemerick.url.URL, taking a map of keywords to field values.\"") "map->query" (dict "arglists" "([m])") "port-str" (dict "arglists" "([protocol port])") "query->map" (dict "arglists" "([qstr])") "split-param" (dict "arglists" "([param])") "url" (dict "arglists" "([url] [base-url & path-segments])" "doc" "\"Returns a new URL record for the given url string(s).\\n\\n   The first argument must be a base url — either a complete url string, or\\n   a pre-existing URL record instance that will serve as the basis for the new\\n   URL.  Any additional arguments must be strings, which are interpreted as\\n   relative paths that are successively resolved against the base url's path\\n   to construct the final :path in the returned URL record. \\n\\n   This function does not perform any url-encoding.  Use `url-encode` to encode\\n   URL path segments as desired before passing them into this fn.\"") "url*" (dict "arglists" "([url])") "url-creds" (dict "arglists" "([username password])") "url-decode" (dict "arglists" "([string] [string encoding])") "url-encode" (dict "arglists" "([string])"))) "clauth.middleware" (dict "aliases" (dict "token" "clauth.token") "interns" (dict "assoc-session" (dict "arglists" "([response req attr value])" "doc" "\"Add session varia\"") "authentication-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 401 Response\"") "csrf-protect!" (dict "arglists" "([app])" "doc" "\"add a csrf token to session and reject a post request without it\"") "csrf-token" (dict "arglists" "([req])" "doc" "\"extract csrf token from request\"") "if-form" (dict "arglists" "([req html api])" "doc" "\"if request is url form encoded it runs the first handler if not the second\"" "macro" "true") "if-html" (dict "arglists" "([req html api])" "doc" "\"if request is for a html page it runs the first handler if not the second\"" "macro" "true") "is-form?" (dict "arglists" "([req])" "doc" "\"returns true if request has form in the accept header\"") "is-html?" (dict "arglists" "([req])" "doc" "\"returns true if request has text/html in the accept header\"") "redirect" (dict "arglists" "([url] [url status])" "doc" "\"Returns a Ring response for an HTTP 302 redirect. Status may be \\n  a key in redirect-status-codes or a numeric code. Defaults to 302\"") "req->session-token-string" (dict "arglists" "([req])" "doc" "\"Return the token string from a session\"") "req->token" (dict "arglists" "([req] [req finder])") "req->token-string" (dict "arglists" "([req])" "doc" "\"Return the token string for a request\"") "requested-uri" (dict "arglists" "([req])") "require-bearer-token!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n\\n   The token is added to the :access-token key of the request.\\n\\n   will return a [HTTP 401 header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.4) if no valid token is present.\"") "require-user-session!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require that user is authenticated via an access_token stored in the session.\\n\\n   Use this to protect parts of your application that web services should not\\n   have access to.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   The token is added to the :access-token key of the request.\\n\\n   Will redirect user to login url if not authenticated and issue a 403 to\\n   other requests.\"") "user-session-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 403 Response or redirects to login\"") "with-csrf-token" (dict "arglists" "([req])" "doc" "\"add a csrf token to request\"") "wrap-bearer-token" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n   The subject is added to the :access-token key of the request.\"") "wrap-user-session" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 token stored in the session. Use this for\\n   optional authentication where no API access is wished.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   The subject is added to the :access-token key of the request.\""))) "clauth.user" (dict "aliases" (dict "cheshire" "cheshire.core" "store" "clauth.store") "interns" (dict "authenticate-user" (dict "arglists" "([login password])" "doc" "\"authenticate user application using login and password\"") "bcrypt" (dict "arglists" "([password])" "doc" "\"Perform BCrypt hash of password\"") "fetch-user" (dict "arglists" "([t])" "doc" "\"Find user based on login\"") "new-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"Create new user record\"") "register-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"create a unique user and store it in the user store\"") "reset-user-store!" (dict "arglists" "([])" "doc" "\"mainly for used in testing. Clears out all users.\"") "store-user" (dict "arglists" "([t])" "doc" "\"Store the given User and return it.\"") "user-store" (dict) "users" (dict "arglists" "([])" "doc" "\"Sequence of users\"") "valid-password?" (dict "arglists" "([candidate hashed])" "doc" "\"Verify that candidate password matches the hashed bcrypted password\""))) "clj-http.client" (dict "aliases" (dict "conn" "clj-http.conn-mgr" "core" "clj-http.core" "str" "clojure.string" "util" "clj-http.util") "interns" (dict "*current-middleware*" (dict "doc" "\"Available at any time to retrieve the middleware being used.\\n  Automatically bound when `with-middleware` is used.\"") "accept-encoding-value" (dict "arglists" "([accept-encoding])") "basic-auth-value" (dict "arglists" "([basic-auth])") "check-url!" (dict "arglists" "([url])") "client-error?" (dict "arglists" "([{:keys [status]}])") "coerce-clojure-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-content-type" (dict) "coerce-form-params" (dict) "coerce-form-urlencoded-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-json-body" (dict "arglists" "([{:keys [coerce]} {:keys [body status], :as resp} keyword? strict? & [charset]])") "coerce-response-body" (dict) "coerce-transit-body" (dict "arglists" "([{:keys [transit-opts], :as request} {:keys [body], :as resp} type])") "coerce-transit-form-params" (dict "arglists" "([type {:keys [form-params transit-opts]}])") "conflict?" (dict "arglists" "([{:keys [status]}])") "content-type-value" (dict "arglists" "([type])") "copy" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "crouton-enabled?" (dict) "decompress-body" (dict) "default-middleware" (dict "doc" "\"The default list of middleware clj-http uses for wrapping requests.\"") "delete" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "detect-charset" (dict "arglists" "([content-type])" "doc" "\"Given a charset header, detect the charset, returns UTF-8 if not found.\"") "dissoc-in" (dict "arglists" "([m [k & ks :as keys]])" "doc" "\"Dissociates an entry from a nested associative structure returning a new\\n  nested structure. keys is a sequence of keys. Any empty maps that result\\n  will not be present in the new structure.\"") "edn-enabled?" (dict) "follow-redirect" (dict "arglists" "([client {:keys [uri url scheme server-name server-port], :as req} {:keys [trace-redirects body], :as resp}])" "doc" "\"Attempts to follow the redirects from the \\\"location\\\" header, if no such\\n  header exists (bad server!), returns the response without following the\\n  request.\"") "form-decode" ...)) "clj-time.coerce" (dict "aliases" (dict "time-fmt" "clj-time.format") "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "ICoerce" (dict) "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" ...)) "clj-time.core" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" (dict "arglists" "([this])" "doc" "\"Returns the first day of the month\"") "floor" ...)) "clj-time.format" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "Mappable" (dict) "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" ...)) "clj-time.periodic" (dict "aliases" (dict "ct" "clj-time.core") "interns" (dict "periodic-seq" (dict "arglists" "([start period-like] [start end period-like])" "doc" "\"Returns a sequence of date-time values growing over specific period.\\n  The 2 argument function takes as input the starting value and the growing value,\\n  returning a lazy infinite sequence.\\n  The 3 argument function takes as input the starting value, the upper bound value,\\n  and the growing value, return a lazy sequence.\""))) "clojure.core.async" (dict "aliases" (dict "buffers" "clojure.core.async.impl.buffers" "channels" "clojure.core.async.impl.channels" "conc" "clojure.core.async.impl.concurrent" "core" "clojure.core" "dispatch" "clojure.core.async.impl.dispatch" "impl" "clojure.core.async.impl.protocols" "ioc" "clojure.core.async.impl.ioc-macros" "mutex" "clojure.core.async.impl.mutex" "timers" "clojure.core.async.impl.timers") "interns" (dict "<!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Must be called inside a (go ...) block. Will\\n  return nil if closed. Will park if nothing is available.\"") "<!!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Will return nil if closed. Will block\\n  if nothing is available.\"") ">!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Must be called\\n  inside a (go ...) block. Will park if no buffer space is available.\\n  Returns true unless port is already closed.\"") ">!!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Will block if no\\n  buffer space is available. Returns true unless port is already closed.\"") "Mix" (dict) "Mult" (dict) "Mux" (dict) "Pub" (dict) "admix" (dict "arglists" "([mix ch])" "doc" "\"Adds ch as an input to the mix\"") "admix*" (dict "arglists" "([m ch])") "alt!" (dict "arglists" "([& clauses])" "doc" "\"Makes a single choice between one of several channel operations,\\n  as if by alts!, returning the value of the result expr corresponding\\n  to the operation completed. Must be called inside a (go ...) block.\\n\\n  Each clause takes the form of:\\n\\n  channel-op[s] result-expr\\n\\n  where channel-ops is one of:\\n\\n  take-port - a single port to take\\n  [take-port | [put-port put-val] ...] - a vector of ports as per alts!\\n  :default | :priority - an option for alts!\\n\\n  and result-expr is either a list beginning with a vector, whereupon that\\n  vector will be treated as a binding for the [val port] return of the\\n  operation, else any other expression.\\n\\n  (alt!\\n    [c t] ([val ch] (foo ch val))\\n    x ([v] v)\\n    [[out val]] :wrote\\n    :default 42)\\n\\n  Each option may appear at most once. The choice and parking\\n  characteristics are those of alts!.\"" "macro" "true") "alt!!" (dict "arglists" "([& clauses])" "doc" "\"Like alt!, except as if by alts!!, will block until completed, and\\n  not intended for use in (go ...) blocks.\"" "macro" "true") "alt-flag" (dict "arglists" "([])") "alt-handler" (dict "arglists" "([flag cb])") "alts!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Completes at most one of several channel operations. Must be called\\n  inside a (go ...) block. ports is a vector of channel endpoints,\\n  which can be either a channel to take from or a vector of\\n  [channel-to-put-to val-to-put], in any combination. Takes will be\\n  made as if by <!, and puts will be made as if by >!. Unless\\n  the :priority option is true, if more than one port operation is\\n  ready a non-deterministic choice will be made. If no operation is\\n  ready and a :default value is supplied, [default-val :default] will\\n  be returned, otherwise alts! will park until the first operation to\\n  become ready completes. Returns [val port] of the completed\\n  operation, where val is the value taken for takes, and a\\n  boolean (true unless already closed, as per put!) for puts.\\n\\n  opts are passed as :key val ... Supported options:\\n\\n  :default val - the value to use if none of the operations are immediately ready\\n  :priority true - (default nil) when true, the operations will be tried in order.\\n\\n  Note: there is no guarantee that the port exps or val exprs will be\\n  used, nor in what order should they be, so they should not be\\n  depended upon for side effects.\"") "alts!!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Like alts!, except takes will be made as if by <!!, and puts will\\n  be made as if by >!!, will block until completed, and not intended\\n  for use in (go ...) blocks.\"") "bounded-count" (dict "arglists" "([n coll])" "doc" "\"Returns the smaller of n or the count of coll, without examining\\n  more than n items if coll is not counted\"") "buffer" (dict "arglists" "([n])" "doc" "\"Returns a fixed buffer of size n. When full, puts will block/park.\"") "chan" (dict "arglists" "([] [buf-or-n] [buf-or-n xform] [buf-or-n xform ex-handler])" "doc" "\"Creates a channel with an optional buffer, an optional transducer\\n  (like (map f), (filter p) etc or a composition thereof), and an\\n  optional exception-handler.  If buf-or-n is a number, will create\\n  and use a fixed buffer of that size. If a transducer is supplied a\\n  buffer must be specified. ex-handler must be a fn of one argument -\\n  if an exception occurs during transformation it will be called with\\n  the Throwable as an argument, and any non-nil return value will be\\n  placed in the channel.\"") "close!" (dict "arglists" "([chan])" "doc" "\"Closes a channel. The channel will no longer accept any puts (they\\n  will be ignored). Data in the channel remains available for taking, until\\n  exhausted, after which takes will return nil. If there are any\\n  pending takes, they will be dispatched with nil. Closing a closed\\n  channel is a no-op. Returns nil.\\n\\n  Logically closing happens after all puts have been delivered. Therefore, any\\n  blocked or parked puts will remain blocked/parked until a taker releases them.\"") "do-alt" (dict "arglists" "([alts clauses])") "do-alts" (dict "arglists" "([fret ports opts])" "doc" "\"returns derefable [val port] if immediate, nil if enqueued\"") "dropping-buffer" (dict "arglists" "([n])" "doc" "\"Returns a buffer of size n. When full, puts will complete but\\n  val will be dropped (no transfer).\"") "fhnop" (dict) "filter<" ...)) "clojure.data.json" (dict "aliases" (dict "pprint" "clojure.pprint") "interns" (dict "*bigdec*" (dict) "*escape-js-separators*" (dict) "*escape-slash*" (dict) "*escape-unicode*" (dict) "*key-fn*" (dict) "*value-fn*" (dict) "-read" (dict "arglists" "([stream eof-error? eof-value])") "-write" (dict "arglists" "([object out])" "doc" "\"Print object to PrintWriter out as JSON\"") "JSONWriter" (dict) "codepoint" (dict "arglists" "([c])" "macro" "true") "codepoint-case" (dict "arglists" "([e & clauses])" "macro" "true") "codepoint-clause" (dict "arglists" "([[test result]])") "default-value-fn" (dict "arglists" "([k v])") "default-write-key-fn" (dict "arglists" "([x])") "json-str" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write-str'.\\n\\n  Converts x to a JSON-formatted string.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn of \\\\uXXXX escapes of Unicode characters.\"") "pprint" (dict "arglists" "([x & options])" "doc" "\"Pretty-prints JSON representation of x to *out*. Options are the\\n  same as for write except :value-fn, which is not supported.\"") "pprint-array" (dict "arglists" "([s])") "pprint-dispatch" (dict "arglists" "([x])") "pprint-generic" (dict "arglists" "([x])") "pprint-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'pprint'.\\n\\n  Pretty-prints JSON representation of x to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "pprint-object" (dict "arglists" "([m])") "print-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write' to *out*.\\n\\n  Write JSON-formatted output to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "read" (dict "arglists" "([reader & options])" "doc" "\"Reads a single item of JSON data from a java.io.Reader. Options are\\n  key-value pairs, valid options are:\\n\\n     :eof-error? boolean\\n\\n        If true (default) will throw exception if the stream is empty.\\n\\n     :eof-value Object\\n\\n        Object to return if the stream is empty and eof-error? is\\n        false. Default is nil.\\n\\n     :bigdec boolean\\n\\n        If true use BigDecimal for decimal numbers instead of Double.\\n        Default is false.\\n\\n     :key-fn function\\n\\n        Single-argument function called on JSON property names; return\\n        value will replace the property names in the output. Default\\n        is clojure.core/identity, use clojure.core/keyword to get\\n        keyword properties.\\n\\n     :value-fn function\\n\\n        Function to transform values in maps (\\\"objects\\\" in JSON) in\\n        the output. For each JSON property, value-fn is called with\\n        two arguments: the property name (transformed by key-fn) and\\n        the value. The return value of value-fn will replace the value\\n        in the output. If value-fn returns itself, the property will\\n        be omitted from the output. The default value-fn returns the\\n        value unchanged. This option does not apply to non-map\\n        collections.\"") "read-array" (dict "arglists" "([stream])") "read-decimal" ...)) "clojure.java.jdbc" (dict "aliases" (dict "str" "clojure.string" "walk" "clojure.walk") "interns" (dict "Connectable" (dict) "IResultSetReadColumn" (dict "doc" "\"Protocol for reading objects from the java.sql.ResultSet. Default\\n   implementations (for Object and nil) return the argument, and the\\n   Boolean implementation ensures a canonicalized true/false value,\\n   but it can be extended to provide custom behavior for special types.\"") "ISQLParameter" (dict "doc" "\"Protocol for setting SQL parameters in statement objects, which\\n   can convert from Clojure values. The default implementation just\\n   delegates the conversion to ISQLValue's sql-value conversion and\\n   uses .setObject on the parameter. It can be extended to use other\\n   methods of PreparedStatement to convert and set parameter values.\"") "ISQLValue" (dict "doc" "\"Protocol for creating SQL values from Clojure values. Default\\n   implementations (for Object and nil) just return the argument,\\n   but it can be extended to provide custom behavior to support\\n   exotic types supported by different databases.\"") "add-connection" (dict "arglists" "([db connection])") "as-properties" (dict "arglists" "([m])" "doc" "\"Convert any seq of pairs to a java.utils.Properties instance.\\n   Uses as-sql-name to convert both keys and values into strings.\"") "as-sql-name" (dict "arglists" "([f] [f x])" "doc" "\"Given a naming strategy function and a keyword or string, return\\n   a string per that naming strategy.\\n   A name of the form x.y is treated as multiple names, x, y, etc,\\n   and each are turned into strings via the naming strategy and then\\n   joined back together so x.y might become `x`.`y` if the naming\\n   strategy quotes identifiers with `.\"") "classnames" (dict "doc" "\"Map of classnames to subprotocols\"") "col-str" (dict "arglists" "([col entities])" "doc" "\"Transform a column spec to an entity name for SQL. The column spec may be a\\n  string, a keyword or a map with a single pair - column name and alias.\"") "create-table-ddl" (dict "arglists" "([table specs] [table specs opts])" "doc" "\"Given a table name and a vector of column specs return the DDL string for\\n  creating that table. An options map may be provided that can contain:\\n  :table-spec -- a string that is appended to the DDL -- and/or\\n  :entities -- a function to specify how column names are transformed.\"") "db-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or throws if there is none)\"") "db-do-commands" (dict "arglists" "([db sql-commands] [db transaction? sql-commands])" "doc" "\"Executes SQL commands on the specified database connection. Wraps the commands\\n  in a transaction if transaction? is true. transaction? can be ommitted and it\\n  defaults to true. Accepts a single SQL command (string) or a vector of them.\\n  Uses executeBatch. This may affect what SQL you can run via db-do-commands.\"") "db-do-execute-prepared-return-keys" (dict "arglists" "([db stmt param-group transaction?])" "doc" "\"Executes a PreparedStatement, optionally in a transaction, and (attempts to)\\n  return any generated keys.\"") "db-do-execute-prepared-statement" (dict "arglists" "([db stmt param-groups transaction?])" "doc" "\"Execute a PreparedStatement, optionally in a transaction.\"") "db-do-prepared" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. Each param-group is a seq of values for all of\\n  the parameters. transaction? can be omitted and defaults to true.\\n  The sql parameter can either be a SQL string or a PreparedStatement.\\n  Return a seq of update counts (one count for each param-group).\"") "db-do-prepared-return-keys" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. The param-group is a seq of values for all of\\n  the parameters. transaction? can be ommitted and will default to true.\\n  Return the generated keys for the (single) update/insert.\\n  A PreparedStatement may be passed in, instead of a SQL string, in which\\n  case :return-keys MUST BE SET on that PreparedStatement!\"") "db-find-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or nil if there is none)\"") "db-is-rollback-only" (dict "arglists" "([db])" "doc" "\"Returns true if the outermost transaction will rollback rather than\\n  commit when complete\"") "db-query-with-resultset" (dict "arglists" "([db sql-params func] [db sql-params func opts])" "doc" "\"Executes a query, then evaluates func passing in the raw ResultSet as an\\n   argument. The second argument is a vector containing either:\\n    [sql & params] - a SQL query, followed by any parameters it needs\\n    [stmt & params] - a PreparedStatement, followed by any parameters it needs\\n                      (the PreparedStatement already contains the SQL query)\\n  The opts map is passed to prepare-statement.\\n  Uses executeQuery. This may affect what SQL you can run via query.\"") "db-set-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will rollback rather than\\n  commit when complete\"") "db-transaction*" (dict "arglists" "([db func] [db func {:keys [isolation read-only?], :as opts}])" "doc" "\"Evaluates func as a transaction on the open database connection. Any\\n  nested transactions are absorbed into the outermost transaction. By\\n  default, all database updates are committed together as a group after\\n  evaluating the outermost body, or rolled back on any uncaught\\n  exception. If rollback is set within scope of the outermost transaction,\\n  the entire transaction will be rolled back rather than committed when\\n  complete.\\n  The isolation option may be :none, :read-committed, :read-uncommitted,\\n  :repeatable-read, or :serializable. Note that not all databases support\\n  all of those isolation levels, and may either throw an exception or\\n  substitute another isolation level.\\n  The read-only? option puts the transaction in readonly mode (if supported).\"") "db-unset-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will not rollback when complete\"") "delete!" (dict "arglists" "([db table where-clause] [db table where-clause {:keys [entities transaction?], :or {entities identity, transaction? true}}])" "doc" "\"Given a database connection, a table name and a where clause of columns to match,\\n  perform a delete. The options may specify how to transform column names in the\\n  map (default 'as-is') and whether to run the delete in a transaction (default true).\\n  Example:\\n    (delete! db :person [\\\"zip = ?\\\" 94546])\\n  is equivalent to:\\n    (execute! db [\\\"DELETE FROM person WHERE zip = ?\\\" 94546])\"") "delete-sql" (dict "arglists" "([table [where & params] entities])" "doc" "\"Given a table name, a where class and its parameters and an optional entities spec,\\n  return a vector of the SQL for that delete operation followed by its parameters. The\\n  entities spec (default 'as-is') specifies how to transform column names.\"") "direction" ...)) "clojure.pprint" (dict "aliases" (dict) "interns" (dict "*code-table*" (dict) "*current-length*" (dict) "*current-level*" (dict) "*default-page-width*" (dict) "*format-str*" (dict) "*print-base*" (dict "doc" "\"The base to use for printing integers and rationals.\"") "*print-circle*" (dict "doc" "\"Mark circular structures (N.B. This is not yet used)\"") "*print-lines*" (dict "doc" "\"Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)\"") "*print-miser-width*" (dict "doc" "\"The column at which to enter miser style. Depending on the dispatch table, \\nmiser style add newlines in more places to try to keep lines short allowing for further \\nlevels of nesting.\"") "*print-pprint-dispatch*" (dict "doc" "\"The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch\\nto modify.\"") "*print-pretty*" (dict "doc" "\"Bind to true if you want write to use pretty printing\"") "*print-radix*" (dict "doc" "\"Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, \\nor 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the \\nradix specifier is in the form #XXr where XX is the decimal value of *print-base* \"") "*print-right-margin*" (dict "doc" "\"Pretty printing will try to avoid anything going beyond this column.\\nSet it to nil to have pprint let the line be arbitrarily long. This will ignore all \\nnon-mandatory newlines.\"") "*print-shared*" (dict "doc" "\"Mark repeated structures rather than repeat them (N.B. This is not yet used)\"") "*print-suppress-namespaces*" (dict "doc" "\"Don't print namespaces with symbols. This is particularly useful when \\npretty printing the results of macro expansions\"") "*symbol-map*" (dict) "abort?" (dict "arglists" "([context])") "absolute-reposition" (dict "arglists" "([navigator position])") "absolute-tabulation" (dict "arglists" "([params navigator offsets])") "add-core-ns" (dict "arglists" "([amap])") "add-english-scales" (dict "arglists" "([parts offset])" "doc" "\"Take a sequence of parts, add scale numbers (e.g., million) and combine into a string\\noffset is a factor of 10^3 to multiply by\"") "add-to-buffer" (dict "arglists" "([this token])") "ancestor?" (dict "arglists" "([parent child])") "arg-navigator" (dict) "base-str" ...)) "clojure.set" (dict "aliases" (dict) "interns" (dict "bubble-max-key" (dict "arglists" "([k coll])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "index" (dict "arglists" "([xrel ks])" "doc" "\"Returns a map of the distinct values of ks in the xrel mapped to a\\n  set of the maps in xrel with the corresponding values of ks.\"") "intersection" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the intersection of the input sets\"") "join" (dict "arglists" "([xrel yrel] [xrel yrel km])" "doc" "\"When passed 2 rels, returns the rel corresponding to the natural\\n  join. When passed an additional keymap, joins on the corresponding\\n  keys.\"") "map-invert" (dict "arglists" "([m])" "doc" "\"Returns the map with the vals mapped to the keys.\"") "project" (dict "arglists" "([xrel ks])" "doc" "\"Returns a rel of the elements of xrel with only the keys in ks\"") "rename" (dict "arglists" "([xrel kmap])" "doc" "\"Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap\"") "rename-keys" (dict "arglists" "([map kmap])" "doc" "\"Returns the map with the keys in kmap renamed to the vals in kmap\"") "select" (dict "arglists" "([pred xset])" "doc" "\"Returns a set of the elements for which pred is true\"") "subset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a subset of set2?\"") "superset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a superset of set2?\"") "union" (dict "arglists" "([] [s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the union of the input sets\""))) "clojure.string" (dict "aliases" (dict) "interns" (dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...)) "clojure.walk" (dict "aliases" (dict) "interns" (dict "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\""))) "clojure.walk2" (dict "aliases" (dict) "interns" (dict "Walkable" (dict) "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form. For\\n  development use only: This function does not perfectly emulate\\n  macroexpansion by the Clojure compiler because it doesn't understand\\n  special forms like 'let'.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "walkt" (dict "arglists" "([coll f])" "doc" "\"If coll is a collection, applies f to each element of the collection\\n  and returns a collection of the results, of the same type and order\\n  as coll. If coll is not a collection, returns it unchanged. \\\"Same\\n  type\\\" means a type with the same behavior. For example, a hash-map\\n  may be returned as an array-map, but a a sorted-map will be returned\\n  as a sorted-map with the same comparator.\"") "walkt-default" (dict "arglists" "([coll f])") "walkt-transient" (dict "arglists" "([coll f])"))) "clostache.parser" (dict "aliases" (dict "io" "clojure.java.io" "str" "clojure.string") "interns" (dict "->Section" (dict "arglists" "([name body start end inverted])" "doc" "\"Positional factory function for class clostache.parser.Section.\"") "convert-path" (dict "arglists" "([tag open-delim close-delim data])" "doc" "\"Convert a tag with a dotted name to nested sections, using the\\n  supplied delimiters to access the value.\"") "convert-paths" (dict "arglists" "([template data])" "doc" "\"Converts tags with dotted tag names to nested sections.\"") "create-partial-replacements" (dict "arglists" "([template partials])" "doc" "\"Creates pairs of partial replacements.\"") "escape-html" (dict "arglists" "([string])" "doc" "\"Replaces angle brackets with the respective HTML entities.\"") "escape-regex" (dict "arglists" "([regex])" "doc" "\"Escapes characters that have special meaning in regular expressions.\"") "extract-section" (dict "arglists" "([template])" "doc" "\"Extracts the outer section from the template.\"") "find-section-end-tag" (dict "arglists" "([template index level])" "doc" "\"Find the matching end tag for a section at the specified level,\\n   starting to search at index.\"") "find-section-start-tag" (dict "arglists" "([template index])" "doc" "\"Find the next section start tag, starting to search at index.\"") "include-partials" (dict "arglists" "([template partials])" "doc" "\"Include partials within the template.\"") "indent-partial" (dict "arglists" "([partial indent])" "doc" "\"Indent all lines of the partial by indent.\"") "join-standalone-delimiter-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) delimiter tags.\"") "join-standalone-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) section/partials\\n   tags.\"") "map->Section" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class clostache.parser.Section, taking a map of keywords to field values.\"") "map-str" (dict "arglists" "([f coll])" "doc" "\"Apply f to each element of coll, concatenate all results into a\\n  String.\"") "next-index" (dict "arglists" "([section regex] [section regex index])" "doc" "\"Return the next index of the supplied regex.\"") "path-data" (dict "arglists" "([elements data])" "doc" "\"Extract the data for the supplied path.\"") "preprocess" (dict "arglists" "([template data partials])" "doc" "\"Preprocesses template and data (e.g. removing comments).\"") "process-set-delimiters" (dict "arglists" "([template data])" "doc" "\"Replaces custom set delimiters with mustaches.\"") "regex-chars" (dict) "remove-comments" (dict "arglists" "([template])" "doc" "\"Removes comments from the template.\"") "render" (dict "arglists" "([template] [template data] [template data partials])" "doc" "\"Renders the template with the data and, if supplied, partials.\"") "render-resource" (dict "arglists" "([path] [path data] [path data partials])" "doc" "\"Renders a resource located on the classpath\"") "render-section" (dict "arglists" "([section data partials])") "render-template" ...)) "crypto.random" (dict "aliases" (dict "string" "clojure.string") "interns" (dict "base32" (dict "arglists" "([size])" "doc" "\"Return a random base32 string of the specified size in bytes.\"") "base64" (dict "arglists" "([size])" "doc" "\"Return a random base64 string of the specified size in bytes.\"") "bytes" (dict "arglists" "([size])" "doc" "\"Returns a random byte array of the specified size.\"") "hex" (dict "arglists" "([size])" "doc" "\"Return a random hex string of the specified size in bytes.\"") "url-part" (dict "arglists" "([size])" "doc" "\"Return a random string suitable for being inserted into URLs. The size\\n  denotes the number of bytes to generate.\""))) "hugsql.core" (dict "aliases" (dict "adapter" "hugsql.adapter" "edn" "clojure.tools.reader.edn" "io" "clojure.java.io" "parameters" "hugsql.parameters" "parser" "hugsql.parser" "string" "clojure.string") "interns" (dict "adapter" (dict) "command-sym" (dict "arglists" "([hdr])") "compile-exprs" (dict "arglists" "([pdef])" "doc" "\"Compile (def) all expressions in a parsed def\"") "db-fn" (dict "arglists" "([sql] [sql command] [sql command result] [sql command result options])" "doc" "\"Given an sql string and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn*" (dict "arglists" "([psql] [psql command] [psql command result] [psql command result options])" "doc" "\"Given parsed sql and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn-map" (dict "arglists" "([pdef options])" "doc" "\"Hashmap of db fn from a parsed def\\n   with the form:\\n   {:fn-name {:meta {:doc \\\"doc string\\\"}\\n              :fn <anon-db-fn>}\"") "db-run" (dict "arglists" "([db sql] [db sql param-data] [db sql param-data command] [db sql param-data command result] [db sql param-data command result options & command-options])" "doc" "\"Given a database spec/connection, sql string,\\n   parameter data, and optional command, result,\\n   and options, run the sql statement\"") "def-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   :quoting options for identifiers are:\\n     :ansi double-quotes: \\\"identifier\\\"\\n     :mysql backticks: `identifier`\\n     :mssql square brackets: [identifier]\\n     :off no quoting (default)\\n\\n   Identifiers containing a period/dot . are split, quoted separately,\\n   and then rejoined. This supports myschema.mytable conventions.\\n\\n   :quoting can be overridden as an option in the calls to functions\\n   created by def-db-fns.\\n\\n   :adapter specifies the HugSQL adapter to use for all defined\\n   functions. The default adapter used is\\n   (hugsql.adapter.clojure-java-jdbc/hugsql-adapter-clojure-java-jdbc)\\n   when :adapter is not given.\\n\\n   See also hugsql.core/set-adapter! to set adapter for all def-db-fns\\n   calls.  Also, :adapter can be specified for individual function\\n   calls (overriding set-adapter! and the :adapter option here).\"" "macro" "true") "def-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "def-expr" (dict "arglists" "([expr] [expr require-str])") "def-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "def-sqlvec-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns-from-string s options?)\\n\\n   where:\\n    - s is a HugSQL-flavored sql string\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "default-db-options" (dict) "default-sqlvec-options" (dict) "expr-name" (dict "arglists" "([expr])") "expr-pass" (dict "arglists" "([sql-template params options])" "doc" "\"Takes an sql template (from hugsql parser) and evaluates the\\n  Clojure expressions resulting in returning an sql template\\n  containing only sql strings and hashmap parameters\"") "get-adapter" (dict "arglists" "([])" "doc" "\"Get an adapter.  Sets default\\n   hugsql.adapter.clojure-java-jdbc\\n   adapter if no adapter is set.\"") "hugsql-command-fn" (dict) "hugsql-result-fn" (dict) "intern-db-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the db fn from a parsed def\"") "intern-sqlvec-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the sqlvec fn from a parsed def\"") "map-of-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n  Usage:\\n\\n   (map-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "map-of-sqlvec-fns-from-string" ...)) "io.aviso.rook" (dict "aliases" (dict "dispatcher" "io.aviso.rook.dispatcher" "medley" "medley.core" "p" "potemkin" "swagger" "io.aviso.rook.swagger" "t" "io.aviso.tracker") "interns" (dict "compose-middleware" (dict "arglists" "([& middlewares])" "doc" "\"Assembles multiple endpoint middleware forms into a single endpoint middleware. Each middleware form\\n  is either a list or a single form, that will be wrapped as a list.\\n\\n  The list is modified so that the first two values passed in are the previous handler and the metadata (associated\\n  with the endpoint function).\\n\\n  The form should evaluate to a new handler, or the old handler. As a convienience, the form may\\n  evaluate to nil, which will keep the original handler passed in.\\n\\n  Returns a function that accepts a handler and middleware and invokes each middleware form in turn, returning\\n  a final handler function.\\n\\n  This is patterned on Clojure's -> threading macro, with some significant differences.\"" "macro" "true") "consume" (dict "arglists" "([coll bindings & body])" "doc" "\"Consume is used to break apart a collection into individual terms.\\n\\n  The format is:\\n\\n      (consume coll [symbol predicate arity ...] body)\\n\\n  The symbol is assigned a value by extracting zero or more values from the collection that\\n  match the predicate. The predicate is passed a single element from the\\n  collection and should return a truth value.\\n\\n  The arity is a keyword that identifies how many values are taken\\n  from the collection.\\n\\n  :one\\n  : The first value in the collection must match the predicate, or an exception is thrown.\\n    The value is assigned to the symbol.  The literal value 1 may be used instead of :one.\\n\\n  :?\\n  : Matches 0 or 1 values from the collection. If the first value does not match the predicate,\\n    then nil is assigned to the symbol.\\n\\n  :*\\n  : Zero or more values from the collection are assigned to the symbol. The symbol may be assigned\\n    an empty collection.\\n\\n  :+\\n  : Matches one or more values; an exception is thrown if there are no matches.\\n\\n  The symbol/pred/arity triplet can be followed by additional triplets.\\n\\n  Although the above description discusses triplets, there are two special predicate values\\n  that are used as just a pair (symbol followed by special predicate), with no arity.\\n\\n  :&\\n  : Used to indicate consumption of all remaining values, if any, from the collection.\\n    It is not followed by an arity, and must be the final term in the bindings vector.\\n\\n  :+\\n  : Used to consume a single value always (throwing an exception if the collection is\\n    empty).\\n\\n  consume expands into a let form, so the symbol in each triplet may be a destructuring form.\\n\\n  As an example, a function that expects an optional map followed by at least\\n  one string, followed by any number of vectors:\\n\\n\\n      (defn example\\n        {:arglists '([options strings... & vectors] [strings... & vectors])}\\n        [& args]\\n        (consume args\\n          [options map? :?       ; nil or a map\\n           strings string? :+    ; seq of strings, at least one\\n           vectors :&]           ; remaining arguments, may be empty\\n           ;; Use options, strings, vectors here\\n           ...))\\n  \"" "macro" "true") "find-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an optional injected value from the request, returning nil if the value does not exist.\"") "get-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an injected value stored in the request. Throws an exception if the value is falsey.\"") "inject" (dict "arglists" "([request key value])" "doc" "\"Merges a single keyword key and value into the map of injectable argument values store in the request.\\n  This is associated with the :injection argument metadata.\"") "inject*" (dict "arglists" "([request injection-map])" "doc" "\"Merges the provided map of injectable argument values into the request. Keys should be keywords\\n  (that will match against function argument symbols, converted to keywords).\"") "namespace-handler" (dict "arglists" "([options & ns-specs] [& ns-specs])" "doc" "\"Examines the given namespaces and produces either a Ring handler or\\n  an asynchronous Ring handler.\\n\\n  Options can be provided as a leading map (which is optional).\\n\\n  The individual namespaces are specified as vectors of the following\\n  shape:\\n\\n      [context? ns-sym argument-resolvers? middleware? nested...?]\\n\\n  The optional fragments are interpreted as below:\\n\\n  context?\\n  : A context (a string, or a vector of strings and/or keywords) to be prepended to paths for all entries\\n  emitted for this namespace.\\n\\n  ns-sym\\n  : The symbol for the namespace that is to be mapped.\\n  : This is the only required value in the namespace specification.\\n\\n  argument-resolvers?\\n  : A map of argument resolvers that apply to the namespace, and to any child namespaces.\\n\\n  middleware?\\n  : Middleware to be applied to terminal handlers found in this\\n  namespace.\\n\\n  nested...?\\n  : Defines child namespaces, each its own recursive namespace specification.\\n  Child namespaces inherit the context, argument resolvers, and middleware\\n  of the containing namespace.\\n\\n  Supported options and their default values:\\n\\n  :arg-resolvers\\n  : Map of symbol to (keyword or function of request) or keyword\\n    to (function of symbol returning function of request). Entries of\\n    the former provide argument resolvers to be used when resolving\\n    arguments named by the given symbol; in the keyword case, a known\\n    resolver factory will be used.\\n  : Normally, the provided map is merged into the map inherited from\\n    the containing namespace (or elsewhere), but this can be controlled\\n    using metadata on the map.\\n  : Tag with {:replace true} to\\n    exclude inherited resolvers and resolver factories; tag with\\n    {:replace-resolvers true} or {:replace-factories true} to leave\\n    out default resolvers or resolver factories, respectively.\\n\\n  :context\\n  : _Default: []_\\n  : A root context that all namespaces are placed under, for example [\\\"api\\\"].\\n\\n  :default-middleware\\n  : _Default: [[default-namespace-middleware]]_\\n  : Default endpoint middleware applied to the basic handler for\\n    each endpoint function (the basic handler resolver arguments and passes\\n    them to the endpoint function).\\n    The default leaves the basic handler unchanged.\\n\\n  :swagger-options\\n  : Options to be passed to [[construct-swagger-object]], that control how the Swagger description is composed and\\n    customized.\\n    Swagger support is only enabled when :swagger-options is non-nil.\\n\\n  Example call:\\n\\n       (namespace-handler\\n         {:context            [\\\"api\\\"]\\n          :swagger-options    swagger/default-swagger-options\\n          :default-middleware custom-middleware\\n          :arg-resolvers      {'if-unmodified-since :header\\n                               'if-modified-since   :header}}\\n         ;; foo & bar use custom-middleware:\\n         [\\\"hotels\\\" 'org.example.resources.hotels\\n           [[:hotel-id \\\"rooms\\\"] 'org.example.resources.rooms]]\\n         [\\\"bars\\\" 'org.example.resources.bars]\\n         ;; taxis has special requirements:\\n         [\\\"taxis\\\" 'org.example.resources.taxis\\n           {:dispatcher dispatcher-resolver-factory}\\n           taxi-middleware]).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "resolve-argument-value" (dict "arglists" "([request argument-meta argument-symbol])" "doc" "\"Resolves an argument, as if it were an argument to an endpoint function.\\n\\n  request\\n  : The Ring request map, as passed through middleware and to the endpoint.\\n\\n  argument-meta\\n  : A map of metadata about the symbol, or a single keyword. A keyword is converted\\n    to a map (of the keyword, to true).\\n\\n  argument-symbol\\n  : A symbol identifying the name of the parameter. This is sometimes needed to construct\\n    the argument resolver function.\\n\\n  Throws an exception if no (single) argument resolver can be identified.\"") "wrap-with-injection" (dict "arglists" "([handler key value])" "doc" "\"Wraps a request handler with an injection of the key and value.\"") "wrap-with-injections" (dict "arglists" "([handler injections])" "doc" "\"Wraps a request handler with injections by merging in a map.\"") "wrap-with-standard-middleware" (dict "arglists" "([handler])" "doc" "\"The standard middleware that Rook expects to be present before it is passed the Ring request.\""))) "io.aviso.rook.server" (dict "aliases" (dict "io" "clojure.java.io" "l" "clojure.tools.logging" "medley" "medley.core" "rook" "io.aviso.rook" "str" "clojure.string" "t" "io.aviso.tracker" "utils" "io.aviso.rook.utils") "interns" (dict "cond-let" (dict "arglists" "([& forms])" "doc" "\"A merging of cond and let.  Each term is either a vector\\n  (in which case, it acts like let) or a condition expression followed by the value\\n  for that expression. An empty cond-let returns nil.\\n\\n  cond-let makes it possible to create readable code that doesn't end up nesting\\n  ;endlessly.\\n\\n  A typical example is where several steps must occur, perhaps reading data from\\n  an external datastore and making a few consistency checks:\\n\\n      (defn apply-payment [db-conn order-id user-id payment-info]\\n        (cond-let\\n          [order (find-order-by-id db-conn order-id)]\\n\\n          (nil? order)\\n          not-found-response\\n\\n          (not (owned-by? order user-id))\\n          forbidden-response\\n\\n          [existing-payment (find-payment db-conn (:payment-id order))]\\n\\n          (some? existing-payment)\\n          already-payed-response\\n\\n          :else\\n          (do\\n            (attach-payment db-conn order payment-info)\\n\\n            updated-response)))\"" "macro" "true") "construct-handler" (dict "arglists" "([{:keys [reload log debug track standard exceptions lazy]} creator & creator-args])" "doc" "\"Constructs a root handler using a creator function.  Normally, the creator function\\n  is invoked immediately, and returns a Ring handler function. However, during development,\\n  to take advantage of code reloading, the creator will be invoked on each incoming request.\\n\\n  To fully take advantage of REPL oriented development, you should pass the Var containing\\n  the creator function, e.g. `#'create-app-handler`.\\n\\n  The optional creator-args are additional arguments to be passed to the creator function;\\n  these are usually configuration data or dependencies.\\n\\n  The options map contains several flags:\\n\\n  :reload\\n  : enables the above-described reloading of the handler.\\n\\n  :lazy\\n  : if true (and :reload is false) then the handler is not created until first needed, rather\\n    then immediately on invoking this function.\\n\\n  :debug\\n  : enables logging (at debug level) of each incoming request via [[wrap-debug-request]]\\n    and [[wrap-debug-response]]\\n\\n  :log\\n  : enables logging of a summary of each incoming request (at info level) via [[wrap-log-request]].\\n\\n  :track\\n  : enables tracking a summary of each incoming request via [[wrap-track-request]].\\n\\n  :standard\\n  : Enables the standard Rook middleware, (see [[wrap-with-standard-middleware]]).\\n\\n  :exceptions\\n  : Enables [[wrap-with-exception-catching]] to catch and report exceptions.\\n\\n  The extra middleware is added around the root handler (or the\\n  reloading handler that creates the root handler).\"") "format-binary" (dict "arglists" "([data & options])" "doc" "\"Formats the data using [[write-binary]] and returns the result as a string.\"") "format-bytes" (dict "arglists" "([label byte-array])") "lazy-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created lazily on first access.\"") "log-request-and-body" (dict "arglists" "([request body-array])") "log-response" (dict "arglists" "([response])" "doc" "\"Logs the response at debug level (if enabled) with nice formatting; returns a new response (since reading\\n  an InputStream body is destructive).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "read-bytes" (dict "arglists" "([stream length])") "reloading-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created fresh on each request;\\n  this is used when developing the application as it supports re-loading of code in a REPL without having to\\n  restart the embedded Jetty instance.\"") "to-message" (dict "arglists" "([t])" "doc" "\"Converts an exception to a message. Normally, this is the message property of the exception, but if\\n  that's blank, the fully qualified class name of the exception is used instead.\"") "wrap-creator" (dict "arglists" "([creator creator-args])" "doc" "\"Wraps a creator and arguments as a function of no arguments. If the creator fails, then\\n  the error is logged and a handler that always responds with a 500 status is returned.\"") "wrap-debug-request" (dict "arglists" "([handler])" "doc" "\"Logs a pretty-printed representation of each incoming request, at level debug. This includes output\\n  of the body's content in ASCII and hex; this means that the entire body (if present) may be consumed\\n  and stored in memory, and replaced with a new InputStream downstream (when debugging is enabled).\"") "wrap-debug-response" (dict "arglists" "([handler])" "doc" "\"Used to log the response sent back to the client at debug level.\"") "wrap-log-request" (dict "arglists" "([handler])" "doc" "\"Logs incoming requests (as info), identifying method and URI.\"") "wrap-track-request" (dict "arglists" "([handler])" "doc" "\"An alternative to [[wrap-log-request]]; adds tracking with a label via [[summarize-request]].\"") "wrap-with-exception-catching" (dict "arglists" "([handler])" "doc" "\"A simple exception catching and reporting wrapper.\\n\\n   Establishes a tracking checkpoint (so it works very well with [[wrap-track-request]].\\n\\n   Exceptions are converted to 500 responses in the standard [[failure-response]] format.\""))) "json-window.core" ...) "id" "4" "repl-type" "clj" "session" "158b7cdb-12a9-4f87-8c96-8f6940cad593" "status" ("state")) response)
  nrepl--dispatch-response((dict "changed-namespaces" (dict "G__42156" (dict "aliases" (dict) "interns" (dict)) "aggregate.core" (dict "aliases" (dict "jdbc" "clojure.java.jdbc" "p" "parsargs.core") "interns" (dict "->1" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :one> relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "->mn" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many> relationship.\\n  Available options:\\n  :query-fn         A function returning records by a foreign key.\\n  :update-links-fn  A function for updating link table records.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to false.\"") "->n" (dict "arglists" "([relation-kw entity-kw] [relation-kw entity-kw options])" "doc" "\"Returns a relation-spec for a :<many relationship.\\n  Available options:\\n  :fk-kw            A keyword denoting the foreign-key name.\\n  :query-fn         A function returning records by a foreign key.\\n  :owned?           A boolean telling if the related entity is owned,\\n                    i.e. will be deleted when the owner or the link is\\n                    deleted. Defaults to true.\"") "default-fk" (dict "arglists" "([entity-kw])" "doc" "\"Returns a keyword that has the suffix '_id'.\"") "default-link-tablename" (dict "arglists" "([a-entity-kw b-entity-kw])" "doc" "\"Takes two tablenames and joins them with '_' and returns the result as keyword.\"") "delete!" (dict "arglists" "([er-config db-spec m] [er-config db-spec entity-kw m-or-id])" "doc" "\"Removes an aggregate datastructure from the database.\\n  Returns the number of deleted records.\"") "delete-dependants!" (dict "arglists" "([er-config db-spec id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw update-links-fn owned?]}]])" "doc" "\"Deletes all records that m contains, and that point by foreign key to m.\\n  Returns the number of deleted records.\"") "delete-prerequisite!" (dict "arglists" "([er-config db-spec m [relation-kw {:keys [relation-type entity-kw fk-kw owned?]}]])" "doc" "\"Deletes a record that m points to by a foreign key.\\n  Returns the number of deleted records or nil.\"") "dissoc-ks" (dict "arglists" "([m ks])" "doc" "\"Remove keys in ks from m.\"") "entity" (dict "arglists" "([& args])" "doc" "\"Returns an entity-spec from an entity keyword, an optional\\n  options-map and an arbitrary number of relation-specs, i.e.\\n      (agg/entity entity-kw options-map? relations)\\n  Available options:\\n  :read-fn       A function (fn [db-spec id]) returning the\\n                 record with primary key value id as a map.\\n  :insert-fn     A function (fn [db-spec row-map]) that inserts\\n                 the row-map as record, and returns the row-map\\n                 containing the new primary key value.\\n  :update-fn     A function (fn [db-spec set-map]) that updates\\n                 the record identified by the primary key value\\n                 within set-map with the values of set-map.\\n  :delete-fn     A function (fn [db-spec id]) that deletes the\\n                 record identified by the primary key value.\\n  :id-kw         The keyword to be used to get/assoc the primary\\n                 key value. It is also used as primary key\\n                 column name in default DB access functions.\"") "entity-parser" (dict) "entityspec?" (dict "arglists" "([x])" "doc" "\"Returns true if x is a vector containing a keyword as first and a\\n  map as second item\"") "er-config-parser" (dict) "extract-id" (dict "arglists" "([id-kw insert-result])" "doc" "\"Extracts id value from results like ({:scope_identity() 2}) or ({:id 2, ...}).\"") "keep-ks" (dict "arglists" "([m ks])" "doc" "\"Removes all but ks keys from map m.\"") "load" (dict "arglists" "([er-config db-spec entity-kw id] [er-config db-spec m])" "doc" "\"Loads an aggregate by `id`. The `entity-kw` denotes the aggregate root.\\n  Returns a map containing the entity-kw in ::entity and all data, or\\n  nil if the entity-kw is unknown or the record does not exist.\"") "load-relation" (dict "arglists" "([er-config db-spec visited id-kw m [relation-kw {:keys [relation-type entity-kw fk-kw query-fn]}]])" "doc" "\"Loads more data according to the specified relation.\"") "load-relations" (dict "arglists" "([er-config db-spec visited m])") "log" (dict "arglists" "([& xs])") "make-delete-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns a delete function [db-spec id -> (Seq id)] for a specific\\n  table, which deletes the record id points to. It returns the number\\n  of deleted records (usually 1), or nil if none was deleted.\\n  The tablename may be passed as string or keyword.\"") "make-entity-options" (dict "arglists" "([tablename] [tablename id-kw])" "doc" "\"Returns a map containing all four default JDBC based implementations\\n  for read, insert, update and delete.\"") "make-er-config" (dict "arglists" "([& args])" "doc" "\"Creates a er-config map from an optional options-map and an\\n  arbitrary number of entity-specs, i.e.\\n      (agg/make-er-config options-map? entities)\\n  Available options:\\n  :read-fn-factory          A function (fn [tablename]) returning the\\n                            default read function.\\n  :insert-fn-factory        A function (fn [tablename]) returning the\\n                            default insert function.\\n  :update-fn-factory        A function (fn [tablename]) returning the\\n                            default update function.\\n  :delete-fn-factory        A function (fn [tablename]) returning the\\n                            default delete function.\\n  :query-<many-fn-factory   A function (fn [tablename fk-kw]) returning\\n                            the default query-for-many function using\\n                            one foreign key.\\n  :query-<many>-fn-factory  A function (fn [tablename linktablename fk-a fk-b])\\n                            returning the default query-for-many function\\n                            that uses a linktable.\\n  :update-links-fn-factory  A function (fn [linktablename fk-a fk-b])\\n                            returning the default function to update\\n                            link tables.\\n  :id-kw                    A keyword that is taken as default primary\\n                            key column name.\\n  :persisted-pred-fn        A predicate (fn [db-spec entity-kw id-kw row-map])\\n                            that returns true if the given row-map is already\\n                            present in DB.\"") "make-insert-fn" (dict "arglists" "([tablename id-kw])" "doc" "\"Returns an insert function [db-spec row-map -> row-map] for a specific table.\\n  It returns the record, possibly augmented with the generated id in\\n  an :id slot. The tablename may be passed as string or keyword.\"") "make-query-<many-fn" (dict "arglists" "([tablename fk-kw])" "doc" "\"Returns a finder function [db-spec id -> (Seq Map)] for a specific\\n  table, that returns -- as sequence of maps -- all records that have\\n  id as value of the foreign key field denoted by fk-kw.\\n  Assumes a simple n to 1 relationship.\"") "make-query-<many>-fn" ...)) "buddy.hashers" (dict "aliases" (dict "bytes" "buddy.core.bytes" "codecs" "buddy.core.codecs" "hash" "buddy.core.hash" "nonce" "buddy.core.nonce" "scrypt" "clojurewerkz.scrypt.core" "str" "clojure.string") "interns" (dict "+iterations+" (dict) "check" (dict "arglists" "([attempt encrypted] [attempt encrypted {:keys [limit setter prefered]}])" "doc" "\"Check if a unencrypted password matches\\n  with another encrypted password.\"") "check-password" (dict "doc" "\"Password verification implementation.\"") "derive" (dict "arglists" "([password] [password options])" "doc" "\"Encrypts a raw string password.\"") "derive-password" (dict "doc" "\"Derive key depending on algorithm.\"") "derive-password-for-legacy-pbkdf2+sha256" (dict "arglists" "([{:keys [alg password salt saltsize iterations]}])") "dispatch" (dict "arglists" "([opts & args])") "encrypt" (dict "doc" "\"Backward compatibility alias for `derive`.\"") "format-password" (dict "doc" "\"Format password depending on algorithm.\"") "must-update?" (dict "doc" "\"Check if the current password configuration\\n  is succeptible to be updatable.\"") "parse-password" (dict "doc" "\"Parse password from string to parts.\""))) "cemerick.url" (dict "aliases" (dict "pathetic" "pathetic.core" "string" "clojure.string") "interns" (dict "->URL" (dict "arglists" "([protocol username password host port path query anchor])" "doc" "\"Positional factory function for class cemerick.url.URL.\"") "map->URL" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class cemerick.url.URL, taking a map of keywords to field values.\"") "map->query" (dict "arglists" "([m])") "port-str" (dict "arglists" "([protocol port])") "query->map" (dict "arglists" "([qstr])") "split-param" (dict "arglists" "([param])") "url" (dict "arglists" "([url] [base-url & path-segments])" "doc" "\"Returns a new URL record for the given url string(s).\\n\\n   The first argument must be a base url — either a complete url string, or\\n   a pre-existing URL record instance that will serve as the basis for the new\\n   URL.  Any additional arguments must be strings, which are interpreted as\\n   relative paths that are successively resolved against the base url's path\\n   to construct the final :path in the returned URL record. \\n\\n   This function does not perform any url-encoding.  Use `url-encode` to encode\\n   URL path segments as desired before passing them into this fn.\"") "url*" (dict "arglists" "([url])") "url-creds" (dict "arglists" "([username password])") "url-decode" (dict "arglists" "([string] [string encoding])") "url-encode" (dict "arglists" "([string])"))) "clauth.middleware" (dict "aliases" (dict "token" "clauth.token") "interns" (dict "assoc-session" (dict "arglists" "([response req attr value])" "doc" "\"Add session varia\"") "authentication-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 401 Response\"") "csrf-protect!" (dict "arglists" "([app])" "doc" "\"add a csrf token to session and reject a post request without it\"") "csrf-token" (dict "arglists" "([req])" "doc" "\"extract csrf token from request\"") "if-form" (dict "arglists" "([req html api])" "doc" "\"if request is url form encoded it runs the first handler if not the second\"" "macro" "true") "if-html" (dict "arglists" "([req html api])" "doc" "\"if request is for a html page it runs the first handler if not the second\"" "macro" "true") "is-form?" (dict "arglists" "([req])" "doc" "\"returns true if request has form in the accept header\"") "is-html?" (dict "arglists" "([req])" "doc" "\"returns true if request has text/html in the accept header\"") "redirect" (dict "arglists" "([url] [url status])" "doc" "\"Returns a Ring response for an HTTP 302 redirect. Status may be \\n  a key in redirect-status-codes or a numeric code. Defaults to 302\"") "req->session-token-string" (dict "arglists" "([req])" "doc" "\"Return the token string from a session\"") "req->token" (dict "arglists" "([req] [req finder])") "req->token-string" (dict "arglists" "([req])" "doc" "\"Return the token string for a request\"") "requested-uri" (dict "arglists" "([req])") "require-bearer-token!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n\\n   The token is added to the :access-token key of the request.\\n\\n   will return a [HTTP 401 header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.4) if no valid token is present.\"") "require-user-session!" (dict "arglists" "([app] [app find-token])" "doc" "\"Require that user is authenticated via an access_token stored in the session.\\n\\n   Use this to protect parts of your application that web services should not\\n   have access to.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the token.\\n\\n   The token is added to the :access-token key of the request.\\n\\n   Will redirect user to login url if not authenticated and issue a 403 to\\n   other requests.\"") "user-session-required-response" (dict "arglists" "([req])" "doc" "\"Return HTTP 403 Response or redirects to login\"") "with-csrf-token" (dict "arglists" "([req])" "doc" "\"add a csrf token to request\"") "wrap-bearer-token" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 bearer token as defined in\\n   http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   * [Authorization header](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.1)\\n   * [Form encoded body parameter](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.2)\\n   * [URI query field](http://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-08#section-2.3)\\n   * Non standard http cookie ('access_token') for use in interactive applications\\n\\n   The subject is added to the :access-token key of the request.\"") "wrap-user-session" (dict "arglists" "([app] [app find-token])" "doc" "\"Wrap request with a OAuth2 token stored in the session. Use this for\\n   optional authentication where no API access is wished.\\n\\n   A find-token function is passed the token and returns a clojure map\\n   describing the subject of the token.\\n\\n   It supports the following ways of setting the token.\\n\\n   The subject is added to the :access-token key of the request.\""))) "clauth.user" (dict "aliases" (dict "cheshire" "cheshire.core" "store" "clauth.store") "interns" (dict "authenticate-user" (dict "arglists" "([login password])" "doc" "\"authenticate user application using login and password\"") "bcrypt" (dict "arglists" "([password])" "doc" "\"Perform BCrypt hash of password\"") "fetch-user" (dict "arglists" "([t])" "doc" "\"Find user based on login\"") "new-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"Create new user record\"") "register-user" (dict "arglists" "([attrs] [login password] [login password name url])" "doc" "\"create a unique user and store it in the user store\"") "reset-user-store!" (dict "arglists" "([])" "doc" "\"mainly for used in testing. Clears out all users.\"") "store-user" (dict "arglists" "([t])" "doc" "\"Store the given User and return it.\"") "user-store" (dict) "users" (dict "arglists" "([])" "doc" "\"Sequence of users\"") "valid-password?" (dict "arglists" "([candidate hashed])" "doc" "\"Verify that candidate password matches the hashed bcrypted password\""))) "clj-http.client" (dict "aliases" (dict "conn" "clj-http.conn-mgr" "core" "clj-http.core" "str" "clojure.string" "util" "clj-http.util") "interns" (dict "*current-middleware*" (dict "doc" "\"Available at any time to retrieve the middleware being used.\\n  Automatically bound when `with-middleware` is used.\"") "accept-encoding-value" (dict "arglists" "([accept-encoding])") "basic-auth-value" (dict "arglists" "([basic-auth])") "check-url!" (dict "arglists" "([url])") "client-error?" (dict "arglists" "([{:keys [status]}])") "coerce-clojure-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-content-type" (dict) "coerce-form-params" (dict) "coerce-form-urlencoded-body" (dict "arglists" "([request {:keys [body], :as resp}])") "coerce-json-body" (dict "arglists" "([{:keys [coerce]} {:keys [body status], :as resp} keyword? strict? & [charset]])") "coerce-response-body" (dict) "coerce-transit-body" (dict "arglists" "([{:keys [transit-opts], :as request} {:keys [body], :as resp} type])") "coerce-transit-form-params" (dict "arglists" "([type {:keys [form-params transit-opts]}])") "conflict?" (dict "arglists" "([{:keys [status]}])") "content-type-value" (dict "arglists" "([type])") "copy" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "crouton-enabled?" (dict) "decompress-body" (dict) "default-middleware" (dict "doc" "\"The default list of middleware clj-http uses for wrapping requests.\"") "delete" (dict "arglists" "([url & [req]])" "doc" "\"Like #'request, but sets the :method and :url as appropriate.\"") "detect-charset" (dict "arglists" "([content-type])" "doc" "\"Given a charset header, detect the charset, returns UTF-8 if not found.\"") "dissoc-in" (dict "arglists" "([m [k & ks :as keys]])" "doc" "\"Dissociates an entry from a nested associative structure returning a new\\n  nested structure. keys is a sequence of keys. Any empty maps that result\\n  will not be present in the new structure.\"") "edn-enabled?" (dict) "follow-redirect" (dict "arglists" "([client {:keys [uri url scheme server-name server-port], :as req} {:keys [trace-redirects body], :as resp}])" "doc" "\"Attempts to follow the redirects from the \\\"location\\\" header, if no such\\n  header exists (bad server!), returns the response without following the\\n  request.\"") "form-decode" ...)) "clj-time.coerce" (dict "aliases" (dict "time-fmt" "clj-time.format") "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "ICoerce" (dict) "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" ...)) "clj-time.core" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" (dict "arglists" "([year month] [dt])") "first-day-of-the-month-" (dict "arglists" "([this])" "doc" "\"Returns the first day of the month\"") "floor" ...)) "clj-time.format" (dict "aliases" (dict) "interns" (dict "DateTimeProtocol" (dict "doc" "\"Interface for various date time functions\"") "InTimeUnitProtocol" (dict "doc" "\"Interface for in-<time unit> functions\"") "Mappable" (dict) "abuts?" (dict "arglists" "([i-a i-b])" "doc" "\"Returns true if Interval i-a abuts i-b, i.e. then end of i-a is exactly the\\n   beginning of i-b.\"") "after?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly after date/time 'that'.\"") "ago" (dict "arglists" "([period])" "doc" "\"Returns a DateTime a supplied period before the present.\\n  e.g. (-> 5 years ago)\"") "available-ids" (dict "arglists" "([])" "doc" "\"Returns a set of available IDs for use with time-zone-for-id.\"") "before?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly before date/time 'that'.\"") "date-midnight" (dict "arglists" "([year] [year month] [year month day])" "doc" "\"Constructs and returns a new DateMidnight in UTC.\\n   Specify the year, month of year, day of month. Note that month and day are\\n   1-indexed. Any number of least-significant components can be ommited, in which case\\n   they will default to 1.\"") "date-time" (dict "arglists" "([year] [year month] [year month day] [year month day hour] [year month day hour minute] [year month day hour minute second] [year month day hour minute second millis])" "doc" "\"Constructs and returns a new DateTime in UTC.\\n   Specify the year, month of year, day of month, hour of day, minute of hour,\\n   second of minute, and millisecond of second. Note that month and day are\\n   1-indexed while hour, second, minute, and millis are 0-indexed.\\n   Any number of least-significant components can be ommited, in which case\\n   they will default to 1 or 0 as appropriate.\"") "day" (dict "arglists" "([this])" "doc" "\"Return the day of month component of the given date/time.\"") "day-of-week" (dict "arglists" "([this])" "doc" "\"Return the day of week component of the given date/time. Monday is 1 and Sunday is 7\"") "days" (dict "arglists" "([] [n])" "doc" "\"Given a number, returns a Period representing that many days.\\n   Without an argument, returns a PeriodType representing only days.\"") "days?" (dict "arglists" "([val])" "doc" "\"Returns true if the given value is an instance of Days\"") "default-time-zone" (dict "arglists" "([])" "doc" "\"Returns the default DateTimeZone for the current environment.\"") "deprecated" (dict "arglists" "([message])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "do-at" (dict "arglists" "([base-date-time & body])" "doc" "\"Like clojure.core/do except evalautes the expression at the given date-time\"" "macro" "true") "do-at*" (dict "arglists" "([base-date-time body-fn])") "earliest" (dict "arglists" "([dt1 dt2] [dts])" "doc" "\"Returns the earliest of the supplied DateTimes\"") "end" (dict "arglists" "([in])" "doc" "\"Returns the end DateTime of an Interval.\"") "epoch" (dict "arglists" "([])" "doc" "\"Returns a DateTime for the begining of the Unix epoch in the UTC time zone.\"") "equal?" (dict "arglists" "([this that])" "doc" "\"Returns true if ReadableDateTime 'this' is strictly equal to date/time 'that'.\"") "extend" (dict "arglists" "([in & by])" "doc" "\"Returns an Interval with an end ReadableDateTime the specified Period after the end\\n   of the given Interval\"") "first-day-of-the-month" ...)) "clj-time.periodic" (dict "aliases" (dict "ct" "clj-time.core") "interns" (dict "periodic-seq" (dict "arglists" "([start period-like] [start end period-like])" "doc" "\"Returns a sequence of date-time values growing over specific period.\\n  The 2 argument function takes as input the starting value and the growing value,\\n  returning a lazy infinite sequence.\\n  The 3 argument function takes as input the starting value, the upper bound value,\\n  and the growing value, return a lazy sequence.\""))) "clojure.core.async" (dict "aliases" (dict "buffers" "clojure.core.async.impl.buffers" "channels" "clojure.core.async.impl.channels" "conc" "clojure.core.async.impl.concurrent" "core" "clojure.core" "dispatch" "clojure.core.async.impl.dispatch" "impl" "clojure.core.async.impl.protocols" "ioc" "clojure.core.async.impl.ioc-macros" "mutex" "clojure.core.async.impl.mutex" "timers" "clojure.core.async.impl.timers") "interns" (dict "<!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Must be called inside a (go ...) block. Will\\n  return nil if closed. Will park if nothing is available.\"") "<!!" (dict "arglists" "([port])" "doc" "\"takes a val from port. Will return nil if closed. Will block\\n  if nothing is available.\"") ">!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Must be called\\n  inside a (go ...) block. Will park if no buffer space is available.\\n  Returns true unless port is already closed.\"") ">!!" (dict "arglists" "([port val])" "doc" "\"puts a val into port. nil values are not allowed. Will block if no\\n  buffer space is available. Returns true unless port is already closed.\"") "Mix" (dict) "Mult" (dict) "Mux" (dict) "Pub" (dict) "admix" (dict "arglists" "([mix ch])" "doc" "\"Adds ch as an input to the mix\"") "admix*" (dict "arglists" "([m ch])") "alt!" (dict "arglists" "([& clauses])" "doc" "\"Makes a single choice between one of several channel operations,\\n  as if by alts!, returning the value of the result expr corresponding\\n  to the operation completed. Must be called inside a (go ...) block.\\n\\n  Each clause takes the form of:\\n\\n  channel-op[s] result-expr\\n\\n  where channel-ops is one of:\\n\\n  take-port - a single port to take\\n  [take-port | [put-port put-val] ...] - a vector of ports as per alts!\\n  :default | :priority - an option for alts!\\n\\n  and result-expr is either a list beginning with a vector, whereupon that\\n  vector will be treated as a binding for the [val port] return of the\\n  operation, else any other expression.\\n\\n  (alt!\\n    [c t] ([val ch] (foo ch val))\\n    x ([v] v)\\n    [[out val]] :wrote\\n    :default 42)\\n\\n  Each option may appear at most once. The choice and parking\\n  characteristics are those of alts!.\"" "macro" "true") "alt!!" (dict "arglists" "([& clauses])" "doc" "\"Like alt!, except as if by alts!!, will block until completed, and\\n  not intended for use in (go ...) blocks.\"" "macro" "true") "alt-flag" (dict "arglists" "([])") "alt-handler" (dict "arglists" "([flag cb])") "alts!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Completes at most one of several channel operations. Must be called\\n  inside a (go ...) block. ports is a vector of channel endpoints,\\n  which can be either a channel to take from or a vector of\\n  [channel-to-put-to val-to-put], in any combination. Takes will be\\n  made as if by <!, and puts will be made as if by >!. Unless\\n  the :priority option is true, if more than one port operation is\\n  ready a non-deterministic choice will be made. If no operation is\\n  ready and a :default value is supplied, [default-val :default] will\\n  be returned, otherwise alts! will park until the first operation to\\n  become ready completes. Returns [val port] of the completed\\n  operation, where val is the value taken for takes, and a\\n  boolean (true unless already closed, as per put!) for puts.\\n\\n  opts are passed as :key val ... Supported options:\\n\\n  :default val - the value to use if none of the operations are immediately ready\\n  :priority true - (default nil) when true, the operations will be tried in order.\\n\\n  Note: there is no guarantee that the port exps or val exprs will be\\n  used, nor in what order should they be, so they should not be\\n  depended upon for side effects.\"") "alts!!" (dict "arglists" "([ports & {:as opts}])" "doc" "\"Like alts!, except takes will be made as if by <!!, and puts will\\n  be made as if by >!!, will block until completed, and not intended\\n  for use in (go ...) blocks.\"") "bounded-count" (dict "arglists" "([n coll])" "doc" "\"Returns the smaller of n or the count of coll, without examining\\n  more than n items if coll is not counted\"") "buffer" (dict "arglists" "([n])" "doc" "\"Returns a fixed buffer of size n. When full, puts will block/park.\"") "chan" (dict "arglists" "([] [buf-or-n] [buf-or-n xform] [buf-or-n xform ex-handler])" "doc" "\"Creates a channel with an optional buffer, an optional transducer\\n  (like (map f), (filter p) etc or a composition thereof), and an\\n  optional exception-handler.  If buf-or-n is a number, will create\\n  and use a fixed buffer of that size. If a transducer is supplied a\\n  buffer must be specified. ex-handler must be a fn of one argument -\\n  if an exception occurs during transformation it will be called with\\n  the Throwable as an argument, and any non-nil return value will be\\n  placed in the channel.\"") "close!" (dict "arglists" "([chan])" "doc" "\"Closes a channel. The channel will no longer accept any puts (they\\n  will be ignored). Data in the channel remains available for taking, until\\n  exhausted, after which takes will return nil. If there are any\\n  pending takes, they will be dispatched with nil. Closing a closed\\n  channel is a no-op. Returns nil.\\n\\n  Logically closing happens after all puts have been delivered. Therefore, any\\n  blocked or parked puts will remain blocked/parked until a taker releases them.\"") "do-alt" (dict "arglists" "([alts clauses])") "do-alts" (dict "arglists" "([fret ports opts])" "doc" "\"returns derefable [val port] if immediate, nil if enqueued\"") "dropping-buffer" (dict "arglists" "([n])" "doc" "\"Returns a buffer of size n. When full, puts will complete but\\n  val will be dropped (no transfer).\"") "fhnop" (dict) "filter<" ...)) "clojure.data.json" (dict "aliases" (dict "pprint" "clojure.pprint") "interns" (dict "*bigdec*" (dict) "*escape-js-separators*" (dict) "*escape-slash*" (dict) "*escape-unicode*" (dict) "*key-fn*" (dict) "*value-fn*" (dict) "-read" (dict "arglists" "([stream eof-error? eof-value])") "-write" (dict "arglists" "([object out])" "doc" "\"Print object to PrintWriter out as JSON\"") "JSONWriter" (dict) "codepoint" (dict "arglists" "([c])" "macro" "true") "codepoint-case" (dict "arglists" "([e & clauses])" "macro" "true") "codepoint-clause" (dict "arglists" "([[test result]])") "default-value-fn" (dict "arglists" "([k v])") "default-write-key-fn" (dict "arglists" "([x])") "json-str" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write-str'.\\n\\n  Converts x to a JSON-formatted string.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn of \\\\uXXXX escapes of Unicode characters.\"") "pprint" (dict "arglists" "([x & options])" "doc" "\"Pretty-prints JSON representation of x to *out*. Options are the\\n  same as for write except :value-fn, which is not supported.\"") "pprint-array" (dict "arglists" "([s])") "pprint-dispatch" (dict "arglists" "([x])") "pprint-generic" (dict "arglists" "([x])") "pprint-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'pprint'.\\n\\n  Pretty-prints JSON representation of x to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "pprint-object" (dict "arglists" "([m])") "print-json" (dict "arglists" "([x & options])" "doc" "\"DEPRECATED; replaced by 'write' to *out*.\\n\\n  Write JSON-formatted output to *out*.\\n\\n  Valid options are:\\n    :escape-unicode false\\n        to turn off \\\\uXXXX escapes of Unicode characters.\"") "read" (dict "arglists" "([reader & options])" "doc" "\"Reads a single item of JSON data from a java.io.Reader. Options are\\n  key-value pairs, valid options are:\\n\\n     :eof-error? boolean\\n\\n        If true (default) will throw exception if the stream is empty.\\n\\n     :eof-value Object\\n\\n        Object to return if the stream is empty and eof-error? is\\n        false. Default is nil.\\n\\n     :bigdec boolean\\n\\n        If true use BigDecimal for decimal numbers instead of Double.\\n        Default is false.\\n\\n     :key-fn function\\n\\n        Single-argument function called on JSON property names; return\\n        value will replace the property names in the output. Default\\n        is clojure.core/identity, use clojure.core/keyword to get\\n        keyword properties.\\n\\n     :value-fn function\\n\\n        Function to transform values in maps (\\\"objects\\\" in JSON) in\\n        the output. For each JSON property, value-fn is called with\\n        two arguments: the property name (transformed by key-fn) and\\n        the value. The return value of value-fn will replace the value\\n        in the output. If value-fn returns itself, the property will\\n        be omitted from the output. The default value-fn returns the\\n        value unchanged. This option does not apply to non-map\\n        collections.\"") "read-array" (dict "arglists" "([stream])") "read-decimal" ...)) "clojure.java.jdbc" (dict "aliases" (dict "str" "clojure.string" "walk" "clojure.walk") "interns" (dict "Connectable" (dict) "IResultSetReadColumn" (dict "doc" "\"Protocol for reading objects from the java.sql.ResultSet. Default\\n   implementations (for Object and nil) return the argument, and the\\n   Boolean implementation ensures a canonicalized true/false value,\\n   but it can be extended to provide custom behavior for special types.\"") "ISQLParameter" (dict "doc" "\"Protocol for setting SQL parameters in statement objects, which\\n   can convert from Clojure values. The default implementation just\\n   delegates the conversion to ISQLValue's sql-value conversion and\\n   uses .setObject on the parameter. It can be extended to use other\\n   methods of PreparedStatement to convert and set parameter values.\"") "ISQLValue" (dict "doc" "\"Protocol for creating SQL values from Clojure values. Default\\n   implementations (for Object and nil) just return the argument,\\n   but it can be extended to provide custom behavior to support\\n   exotic types supported by different databases.\"") "add-connection" (dict "arglists" "([db connection])") "as-properties" (dict "arglists" "([m])" "doc" "\"Convert any seq of pairs to a java.utils.Properties instance.\\n   Uses as-sql-name to convert both keys and values into strings.\"") "as-sql-name" (dict "arglists" "([f] [f x])" "doc" "\"Given a naming strategy function and a keyword or string, return\\n   a string per that naming strategy.\\n   A name of the form x.y is treated as multiple names, x, y, etc,\\n   and each are turned into strings via the naming strategy and then\\n   joined back together so x.y might become `x`.`y` if the naming\\n   strategy quotes identifiers with `.\"") "classnames" (dict "doc" "\"Map of classnames to subprotocols\"") "col-str" (dict "arglists" "([col entities])" "doc" "\"Transform a column spec to an entity name for SQL. The column spec may be a\\n  string, a keyword or a map with a single pair - column name and alias.\"") "create-table-ddl" (dict "arglists" "([table specs] [table specs opts])" "doc" "\"Given a table name and a vector of column specs return the DDL string for\\n  creating that table. An options map may be provided that can contain:\\n  :table-spec -- a string that is appended to the DDL -- and/or\\n  :entities -- a function to specify how column names are transformed.\"") "db-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or throws if there is none)\"") "db-do-commands" (dict "arglists" "([db sql-commands] [db transaction? sql-commands])" "doc" "\"Executes SQL commands on the specified database connection. Wraps the commands\\n  in a transaction if transaction? is true. transaction? can be ommitted and it\\n  defaults to true. Accepts a single SQL command (string) or a vector of them.\\n  Uses executeBatch. This may affect what SQL you can run via db-do-commands.\"") "db-do-execute-prepared-return-keys" (dict "arglists" "([db stmt param-group transaction?])" "doc" "\"Executes a PreparedStatement, optionally in a transaction, and (attempts to)\\n  return any generated keys.\"") "db-do-execute-prepared-statement" (dict "arglists" "([db stmt param-groups transaction?])" "doc" "\"Execute a PreparedStatement, optionally in a transaction.\"") "db-do-prepared" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. Each param-group is a seq of values for all of\\n  the parameters. transaction? can be omitted and defaults to true.\\n  The sql parameter can either be a SQL string or a PreparedStatement.\\n  Return a seq of update counts (one count for each param-group).\"") "db-do-prepared-return-keys" (dict "arglists" "([db sql-params] [db transaction? sql-params] [db transaction? sql-params opts])" "doc" "\"Executes an (optionally parameterized) SQL prepared statement on the\\n  open database connection. The param-group is a seq of values for all of\\n  the parameters. transaction? can be ommitted and will default to true.\\n  Return the generated keys for the (single) update/insert.\\n  A PreparedStatement may be passed in, instead of a SQL string, in which\\n  case :return-keys MUST BE SET on that PreparedStatement!\"") "db-find-connection" (dict "arglists" "([db])" "doc" "\"Returns the current database connection (or nil if there is none)\"") "db-is-rollback-only" (dict "arglists" "([db])" "doc" "\"Returns true if the outermost transaction will rollback rather than\\n  commit when complete\"") "db-query-with-resultset" (dict "arglists" "([db sql-params func] [db sql-params func opts])" "doc" "\"Executes a query, then evaluates func passing in the raw ResultSet as an\\n   argument. The second argument is a vector containing either:\\n    [sql & params] - a SQL query, followed by any parameters it needs\\n    [stmt & params] - a PreparedStatement, followed by any parameters it needs\\n                      (the PreparedStatement already contains the SQL query)\\n  The opts map is passed to prepare-statement.\\n  Uses executeQuery. This may affect what SQL you can run via query.\"") "db-set-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will rollback rather than\\n  commit when complete\"") "db-transaction*" (dict "arglists" "([db func] [db func {:keys [isolation read-only?], :as opts}])" "doc" "\"Evaluates func as a transaction on the open database connection. Any\\n  nested transactions are absorbed into the outermost transaction. By\\n  default, all database updates are committed together as a group after\\n  evaluating the outermost body, or rolled back on any uncaught\\n  exception. If rollback is set within scope of the outermost transaction,\\n  the entire transaction will be rolled back rather than committed when\\n  complete.\\n  The isolation option may be :none, :read-committed, :read-uncommitted,\\n  :repeatable-read, or :serializable. Note that not all databases support\\n  all of those isolation levels, and may either throw an exception or\\n  substitute another isolation level.\\n  The read-only? option puts the transaction in readonly mode (if supported).\"") "db-unset-rollback-only!" (dict "arglists" "([db])" "doc" "\"Marks the outermost transaction such that it will not rollback when complete\"") "delete!" (dict "arglists" "([db table where-clause] [db table where-clause {:keys [entities transaction?], :or {entities identity, transaction? true}}])" "doc" "\"Given a database connection, a table name and a where clause of columns to match,\\n  perform a delete. The options may specify how to transform column names in the\\n  map (default 'as-is') and whether to run the delete in a transaction (default true).\\n  Example:\\n    (delete! db :person [\\\"zip = ?\\\" 94546])\\n  is equivalent to:\\n    (execute! db [\\\"DELETE FROM person WHERE zip = ?\\\" 94546])\"") "delete-sql" (dict "arglists" "([table [where & params] entities])" "doc" "\"Given a table name, a where class and its parameters and an optional entities spec,\\n  return a vector of the SQL for that delete operation followed by its parameters. The\\n  entities spec (default 'as-is') specifies how to transform column names.\"") "direction" ...)) "clojure.pprint" (dict "aliases" (dict) "interns" (dict "*code-table*" (dict) "*current-length*" (dict) "*current-level*" (dict) "*default-page-width*" (dict) "*format-str*" (dict) "*print-base*" (dict "doc" "\"The base to use for printing integers and rationals.\"") "*print-circle*" (dict "doc" "\"Mark circular structures (N.B. This is not yet used)\"") "*print-lines*" (dict "doc" "\"Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)\"") "*print-miser-width*" (dict "doc" "\"The column at which to enter miser style. Depending on the dispatch table, \\nmiser style add newlines in more places to try to keep lines short allowing for further \\nlevels of nesting.\"") "*print-pprint-dispatch*" (dict "doc" "\"The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch\\nto modify.\"") "*print-pretty*" (dict "doc" "\"Bind to true if you want write to use pretty printing\"") "*print-radix*" (dict "doc" "\"Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, \\nor 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the \\nradix specifier is in the form #XXr where XX is the decimal value of *print-base* \"") "*print-right-margin*" (dict "doc" "\"Pretty printing will try to avoid anything going beyond this column.\\nSet it to nil to have pprint let the line be arbitrarily long. This will ignore all \\nnon-mandatory newlines.\"") "*print-shared*" (dict "doc" "\"Mark repeated structures rather than repeat them (N.B. This is not yet used)\"") "*print-suppress-namespaces*" (dict "doc" "\"Don't print namespaces with symbols. This is particularly useful when \\npretty printing the results of macro expansions\"") "*symbol-map*" (dict) "abort?" (dict "arglists" "([context])") "absolute-reposition" (dict "arglists" "([navigator position])") "absolute-tabulation" (dict "arglists" "([params navigator offsets])") "add-core-ns" (dict "arglists" "([amap])") "add-english-scales" (dict "arglists" "([parts offset])" "doc" "\"Take a sequence of parts, add scale numbers (e.g., million) and combine into a string\\noffset is a factor of 10^3 to multiply by\"") "add-to-buffer" (dict "arglists" "([this token])") "ancestor?" (dict "arglists" "([parent child])") "arg-navigator" (dict) "base-str" ...)) "clojure.set" (dict "aliases" (dict) "interns" (dict "bubble-max-key" (dict "arglists" "([k coll])") "difference" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the first set without elements of the remaining sets\"") "index" (dict "arglists" "([xrel ks])" "doc" "\"Returns a map of the distinct values of ks in the xrel mapped to a\\n  set of the maps in xrel with the corresponding values of ks.\"") "intersection" (dict "arglists" "([s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the intersection of the input sets\"") "join" (dict "arglists" "([xrel yrel] [xrel yrel km])" "doc" "\"When passed 2 rels, returns the rel corresponding to the natural\\n  join. When passed an additional keymap, joins on the corresponding\\n  keys.\"") "map-invert" (dict "arglists" "([m])" "doc" "\"Returns the map with the vals mapped to the keys.\"") "project" (dict "arglists" "([xrel ks])" "doc" "\"Returns a rel of the elements of xrel with only the keys in ks\"") "rename" (dict "arglists" "([xrel kmap])" "doc" "\"Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap\"") "rename-keys" (dict "arglists" "([map kmap])" "doc" "\"Returns the map with the keys in kmap renamed to the vals in kmap\"") "select" (dict "arglists" "([pred xset])" "doc" "\"Returns a set of the elements for which pred is true\"") "subset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a subset of set2?\"") "superset?" (dict "arglists" "([set1 set2])" "doc" "\"Is set1 a superset of set2?\"") "union" (dict "arglists" "([] [s1] [s1 s2] [s1 s2 & sets])" "doc" "\"Return a set that is the union of the input sets\""))) "clojure.string" (dict "aliases" (dict) "interns" (dict "blank?" (dict "arglists" "([s])" "doc" "\"True if s is nil, empty, or contains only whitespace.\"") "capitalize" (dict "arglists" "([s])" "doc" "\"Converts first character of the string to upper-case, all other\\n  characters to lower-case.\"") "ends-with?" (dict "arglists" "([s substr])" "doc" "\"True if s ends with substr.\"") "escape" (dict "arglists" "([s cmap])" "doc" "\"Return a new string, using cmap to escape each character ch\\n   from s as follows:\\n   \\n   If (cmap ch) is nil, append ch to the new string.\\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"") "includes?" (dict "arglists" "([s substr])" "doc" "\"True if s includes substr.\"") "index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return index of value (string or char) in s, optionally searching\\n  forward from from-index or nil if not found.\"") "join" (dict "arglists" "([coll] [separator coll])" "doc" "\"Returns a string of all elements in coll, as returned by (seq coll),\\n   separated by an optional separator.\"") "last-index-of" (dict "arglists" "([s value] [s value from-index])" "doc" "\"Return last index of value (string or char) in s, optionally\\n  searching backward from from-index or nil if not found.\"") "lower-case" (dict "arglists" "([s])" "doc" "\"Converts string to all lower-case.\"") "re-quote-replacement" (dict "arglists" "([replacement])" "doc" "\"Given a replacement string that you wish to be a literal\\n   replacement for a pattern match in replace or replace-first, do the\\n   necessary escaping of special characters in the replacement.\"") "replace" (dict "arglists" "([s match replacement])" "doc" "\"Replaces all instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   string / string\\n   char / char\\n   pattern / (string or function of match).\\n\\n   See also replace-first.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\\n   -> \\\"lmostAay igPay atinLay\\\"\"") "replace-by" (dict "arglists" "([s re f])") "replace-first" (dict "arglists" "([s match replacement])" "doc" "\"Replaces the first instance of match with replacement in s.\\n\\n   match/replacement can be:\\n\\n   char / char\\n   string / string\\n   pattern / (string or function of match).\\n\\n   See also replace.\\n\\n   The replacement is literal (i.e. none of its characters are treated\\n   specially) for all cases above except pattern / string.\\n\\n   For pattern / string, $1, $2, etc. in the replacement string are\\n   substituted with the string that matched the corresponding\\n   parenthesized group in the pattern.  If you wish your replacement\\n   string r to be used literally, use (re-quote-replacement r) as the\\n   replacement argument.  See also documentation for\\n   java.util.regex.Matcher's appendReplacement method.\\n\\n   Example:\\n   (clojure.string/replace-first \\\"swap first two words\\\"\\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\\n   -> \\\"first swap two words\\\"\"") "replace-first-by" (dict "arglists" "([s re f])") "replace-first-char" (dict "arglists" "([s match replace])") "replace-first-str" (dict "arglists" "([s match replace])") "reverse" (dict "arglists" "([s])" "doc" "\"Returns s with its characters reversed.\"") "split" (dict "arglists" "([s re] [s re limit])" "doc" "\"Splits string on a regular expression.  Optional argument limit is\\n  the maximum number of splits. Not lazy. Returns vector of the splits.\"") "split-lines" (dict "arglists" "([s])" "doc" "\"Splits s on \\\\n or \\\\r\\\\n.\"") "starts-with?" (dict "arglists" "([s substr])" "doc" "\"True if s starts with substr.\"") "trim" (dict "arglists" "([s])" "doc" "\"Removes whitespace from both ends of string.\"") "trim-newline" (dict "arglists" "([s])" "doc" "\"Removes all trailing newline \\\\n or return \\\\r characters from\\n  string.  Similar to Perl's chomp.\"") "triml" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the left side of string.\"") "trimr" (dict "arglists" "([s])" "doc" "\"Removes whitespace from the right side of string.\"") "upper-case" ...)) "clojure.walk" (dict "aliases" (dict) "interns" (dict "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\""))) "clojure.walk2" (dict "aliases" (dict) "interns" (dict "Walkable" (dict) "keywordize-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from strings to keywords.\"") "macroexpand-all" (dict "arglists" "([form])" "doc" "\"Recursively performs all possible macroexpansions in form. For\\n  development use only: This function does not perfectly emulate\\n  macroexpansion by the Clojure compiler because it doesn't understand\\n  special forms like 'let'.\"") "postwalk" (dict "arglists" "([f form])" "doc" "\"Performs a depth-first, post-order traversal of form.  Calls f on\\n  each sub-form, uses f's return value in place of the original.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "postwalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of postwalk by printing each form as it is\\n  walked.  Returns form.\"") "postwalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the leaves of the tree first.\"") "prewalk" (dict "arglists" "([f form])" "doc" "\"Like postwalk, but does pre-order traversal.\"") "prewalk-demo" (dict "arglists" "([form])" "doc" "\"Demonstrates the behavior of prewalk by printing each form as it is\\n  walked.  Returns form.\"") "prewalk-replace" (dict "arglists" "([smap form])" "doc" "\"Recursively transforms form by replacing keys in smap with their\\n  values.  Like clojure/replace but works on any data structure.  Does\\n  replacement at the root of the tree first.\"") "stringify-keys" (dict "arglists" "([m])" "doc" "\"Recursively transforms all map keys from keywords to strings.\"") "walk" (dict "arglists" "([inner outer form])" "doc" "\"Traverses form, an arbitrary data structure.  inner and outer are\\n  functions.  Applies inner to each element of form, building up a\\n  data structure of the same type, then applies outer to the result.\\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"") "walkt" (dict "arglists" "([coll f])" "doc" "\"If coll is a collection, applies f to each element of the collection\\n  and returns a collection of the results, of the same type and order\\n  as coll. If coll is not a collection, returns it unchanged. \\\"Same\\n  type\\\" means a type with the same behavior. For example, a hash-map\\n  may be returned as an array-map, but a a sorted-map will be returned\\n  as a sorted-map with the same comparator.\"") "walkt-default" (dict "arglists" "([coll f])") "walkt-transient" (dict "arglists" "([coll f])"))) "clostache.parser" (dict "aliases" (dict "io" "clojure.java.io" "str" "clojure.string") "interns" (dict "->Section" (dict "arglists" "([name body start end inverted])" "doc" "\"Positional factory function for class clostache.parser.Section.\"") "convert-path" (dict "arglists" "([tag open-delim close-delim data])" "doc" "\"Convert a tag with a dotted name to nested sections, using the\\n  supplied delimiters to access the value.\"") "convert-paths" (dict "arglists" "([template data])" "doc" "\"Converts tags with dotted tag names to nested sections.\"") "create-partial-replacements" (dict "arglists" "([template partials])" "doc" "\"Creates pairs of partial replacements.\"") "escape-html" (dict "arglists" "([string])" "doc" "\"Replaces angle brackets with the respective HTML entities.\"") "escape-regex" (dict "arglists" "([regex])" "doc" "\"Escapes characters that have special meaning in regular expressions.\"") "extract-section" (dict "arglists" "([template])" "doc" "\"Extracts the outer section from the template.\"") "find-section-end-tag" (dict "arglists" "([template index level])" "doc" "\"Find the matching end tag for a section at the specified level,\\n   starting to search at index.\"") "find-section-start-tag" (dict "arglists" "([template index])" "doc" "\"Find the next section start tag, starting to search at index.\"") "include-partials" (dict "arglists" "([template partials])" "doc" "\"Include partials within the template.\"") "indent-partial" (dict "arglists" "([partial indent])" "doc" "\"Indent all lines of the partial by indent.\"") "join-standalone-delimiter-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) delimiter tags.\"") "join-standalone-tags" (dict "arglists" "([template])" "doc" "\"Remove newlines after standalone (i.e. on their own line) section/partials\\n   tags.\"") "map->Section" (dict "arglists" "([m__6522__auto__])" "doc" "\"Factory function for class clostache.parser.Section, taking a map of keywords to field values.\"") "map-str" (dict "arglists" "([f coll])" "doc" "\"Apply f to each element of coll, concatenate all results into a\\n  String.\"") "next-index" (dict "arglists" "([section regex] [section regex index])" "doc" "\"Return the next index of the supplied regex.\"") "path-data" (dict "arglists" "([elements data])" "doc" "\"Extract the data for the supplied path.\"") "preprocess" (dict "arglists" "([template data partials])" "doc" "\"Preprocesses template and data (e.g. removing comments).\"") "process-set-delimiters" (dict "arglists" "([template data])" "doc" "\"Replaces custom set delimiters with mustaches.\"") "regex-chars" (dict) "remove-comments" (dict "arglists" "([template])" "doc" "\"Removes comments from the template.\"") "render" (dict "arglists" "([template] [template data] [template data partials])" "doc" "\"Renders the template with the data and, if supplied, partials.\"") "render-resource" (dict "arglists" "([path] [path data] [path data partials])" "doc" "\"Renders a resource located on the classpath\"") "render-section" (dict "arglists" "([section data partials])") "render-template" ...)) "crypto.random" (dict "aliases" (dict "string" "clojure.string") "interns" (dict "base32" (dict "arglists" "([size])" "doc" "\"Return a random base32 string of the specified size in bytes.\"") "base64" (dict "arglists" "([size])" "doc" "\"Return a random base64 string of the specified size in bytes.\"") "bytes" (dict "arglists" "([size])" "doc" "\"Returns a random byte array of the specified size.\"") "hex" (dict "arglists" "([size])" "doc" "\"Return a random hex string of the specified size in bytes.\"") "url-part" (dict "arglists" "([size])" "doc" "\"Return a random string suitable for being inserted into URLs. The size\\n  denotes the number of bytes to generate.\""))) "hugsql.core" (dict "aliases" (dict "adapter" "hugsql.adapter" "edn" "clojure.tools.reader.edn" "io" "clojure.java.io" "parameters" "hugsql.parameters" "parser" "hugsql.parser" "string" "clojure.string") "interns" (dict "adapter" (dict) "command-sym" (dict "arglists" "([hdr])") "compile-exprs" (dict "arglists" "([pdef])" "doc" "\"Compile (def) all expressions in a parsed def\"") "db-fn" (dict "arglists" "([sql] [sql command] [sql command result] [sql command result options])" "doc" "\"Given an sql string and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn*" (dict "arglists" "([psql] [psql command] [psql command result] [psql command result options])" "doc" "\"Given parsed sql and optionally a command, result, and options,\\n  return an anonymous function that can run hugsql database\\n  execute/queries and supports hugsql parameter replacement\"") "db-fn-map" (dict "arglists" "([pdef options])" "doc" "\"Hashmap of db fn from a parsed def\\n   with the form:\\n   {:fn-name {:meta {:doc \\\"doc string\\\"}\\n              :fn <anon-db-fn>}\"") "db-run" (dict "arglists" "([db sql] [db sql param-data] [db sql param-data command] [db sql param-data command result] [db sql param-data command result options & command-options])" "doc" "\"Given a database spec/connection, sql string,\\n   parameter data, and optional command, result,\\n   and options, run the sql statement\"") "def-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   :quoting options for identifiers are:\\n     :ansi double-quotes: \\\"identifier\\\"\\n     :mysql backticks: `identifier`\\n     :mssql square brackets: [identifier]\\n     :off no quoting (default)\\n\\n   Identifiers containing a period/dot . are split, quoted separately,\\n   and then rejoined. This supports myschema.mytable conventions.\\n\\n   :quoting can be overridden as an option in the calls to functions\\n   created by def-db-fns.\\n\\n   :adapter specifies the HugSQL adapter to use for all defined\\n   functions. The default adapter used is\\n   (hugsql.adapter.clojure-java-jdbc/hugsql-adapter-clojure-java-jdbc)\\n   when :adapter is not given.\\n\\n   See also hugsql.core/set-adapter! to set adapter for all def-db-fns\\n   calls.  Also, :adapter can be specified for individual function\\n   calls (overriding set-adapter! and the :adapter option here).\"" "macro" "true") "def-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the database\\n   functions in the current namespace.\\n\\n   Usage:\\n\\n   (def-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "def-expr" (dict "arglists" "([expr] [expr require-str])") "def-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "def-sqlvec-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, define the <name>-sqlvec functions in the\\n  current namespace.  Returns sqlvec format: a vector of SQL and\\n  parameter values. (e.g., [\\\"select * from test where id = ?\\\" 42])\\n\\n  Usage:\\n\\n   (def-sqlvec-fns-from-string s options?)\\n\\n   where:\\n    - s is a HugSQL-flavored sql string\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "default-db-options" (dict) "default-sqlvec-options" (dict) "expr-name" (dict "arglists" "([expr])") "expr-pass" (dict "arglists" "([sql-template params options])" "doc" "\"Takes an sql template (from hugsql parser) and evaluates the\\n  Clojure expressions resulting in returning an sql template\\n  containing only sql strings and hashmap parameters\"") "get-adapter" (dict "arglists" "([])" "doc" "\"Get an adapter.  Sets default\\n   hugsql.adapter.clojure-java-jdbc\\n   adapter if no adapter is set.\"") "hugsql-command-fn" (dict) "hugsql-result-fn" (dict) "intern-db-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the db fn from a parsed def\"") "intern-sqlvec-fn" (dict "arglists" "([pdef options])" "doc" "\"Intern the sqlvec fn from a parsed def\"") "map-of-db-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-db-fns-from-string" (dict "arglists" "([s] [s options])" "doc" "\"Given a HugSQL SQL string, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n   Usage:\\n\\n   (map-of-db-fns-from-string s options?)\\n\\n   where:\\n    - s is a string of HugSQL-flavored sql statements\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :adapter adapter }\\n\\n   See hugsql.core/def-db-fns for :quoting and :adapter details.\"" "macro" "true") "map-of-sqlvec-fns" (dict "arglists" "([file] [file options])" "doc" "\"Given a HugSQL SQL file, return a hashmap of database\\n   functions of the form:\\n\\n   {:fn1-name {:meta {:doc \\\"doc string\\\"}\\n               :fn <fn1>}\\n    :fn2-name {:meta {:doc \\\"doc string\\\"\\n                      :private true}\\n               :fn <fn2>}}\\n\\n  Usage:\\n\\n   (map-sqlvec-fns file options?)\\n\\n   where:\\n    - file is a string file path in your classpath,\\n      a resource object (java.net.URL),\\n      or a file object (java.io.File)\\n    - options (optional) hashmap:\\n      {:quoting :off(default) | :ansi | :mysql | :mssql\\n       :fn-suffix \\\"-sqlvec\\\" (default)\\n\\n   See hugsql.core/def-db-fns for :quoting option details.\\n\\n   :fn-suffix is appended to the defined function names to\\n   differentiate them from the functions defined by def-db-fns.\"" "macro" "true") "map-of-sqlvec-fns-from-string" ...)) "io.aviso.rook" (dict "aliases" (dict "dispatcher" "io.aviso.rook.dispatcher" "medley" "medley.core" "p" "potemkin" "swagger" "io.aviso.rook.swagger" "t" "io.aviso.tracker") "interns" (dict "compose-middleware" (dict "arglists" "([& middlewares])" "doc" "\"Assembles multiple endpoint middleware forms into a single endpoint middleware. Each middleware form\\n  is either a list or a single form, that will be wrapped as a list.\\n\\n  The list is modified so that the first two values passed in are the previous handler and the metadata (associated\\n  with the endpoint function).\\n\\n  The form should evaluate to a new handler, or the old handler. As a convienience, the form may\\n  evaluate to nil, which will keep the original handler passed in.\\n\\n  Returns a function that accepts a handler and middleware and invokes each middleware form in turn, returning\\n  a final handler function.\\n\\n  This is patterned on Clojure's -> threading macro, with some significant differences.\"" "macro" "true") "consume" (dict "arglists" "([coll bindings & body])" "doc" "\"Consume is used to break apart a collection into individual terms.\\n\\n  The format is:\\n\\n      (consume coll [symbol predicate arity ...] body)\\n\\n  The symbol is assigned a value by extracting zero or more values from the collection that\\n  match the predicate. The predicate is passed a single element from the\\n  collection and should return a truth value.\\n\\n  The arity is a keyword that identifies how many values are taken\\n  from the collection.\\n\\n  :one\\n  : The first value in the collection must match the predicate, or an exception is thrown.\\n    The value is assigned to the symbol.  The literal value 1 may be used instead of :one.\\n\\n  :?\\n  : Matches 0 or 1 values from the collection. If the first value does not match the predicate,\\n    then nil is assigned to the symbol.\\n\\n  :*\\n  : Zero or more values from the collection are assigned to the symbol. The symbol may be assigned\\n    an empty collection.\\n\\n  :+\\n  : Matches one or more values; an exception is thrown if there are no matches.\\n\\n  The symbol/pred/arity triplet can be followed by additional triplets.\\n\\n  Although the above description discusses triplets, there are two special predicate values\\n  that are used as just a pair (symbol followed by special predicate), with no arity.\\n\\n  :&\\n  : Used to indicate consumption of all remaining values, if any, from the collection.\\n    It is not followed by an arity, and must be the final term in the bindings vector.\\n\\n  :+\\n  : Used to consume a single value always (throwing an exception if the collection is\\n    empty).\\n\\n  consume expands into a let form, so the symbol in each triplet may be a destructuring form.\\n\\n  As an example, a function that expects an optional map followed by at least\\n  one string, followed by any number of vectors:\\n\\n\\n      (defn example\\n        {:arglists '([options strings... & vectors] [strings... & vectors])}\\n        [& args]\\n        (consume args\\n          [options map? :?       ; nil or a map\\n           strings string? :+    ; seq of strings, at least one\\n           vectors :&]           ; remaining arguments, may be empty\\n           ;; Use options, strings, vectors here\\n           ...))\\n  \"" "macro" "true") "find-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an optional injected value from the request, returning nil if the value does not exist.\"") "get-injection" (dict "arglists" "([request injection-key])" "doc" "\"Retrieves an injected value stored in the request. Throws an exception if the value is falsey.\"") "inject" (dict "arglists" "([request key value])" "doc" "\"Merges a single keyword key and value into the map of injectable argument values store in the request.\\n  This is associated with the :injection argument metadata.\"") "inject*" (dict "arglists" "([request injection-map])" "doc" "\"Merges the provided map of injectable argument values into the request. Keys should be keywords\\n  (that will match against function argument symbols, converted to keywords).\"") "namespace-handler" (dict "arglists" "([options & ns-specs] [& ns-specs])" "doc" "\"Examines the given namespaces and produces either a Ring handler or\\n  an asynchronous Ring handler.\\n\\n  Options can be provided as a leading map (which is optional).\\n\\n  The individual namespaces are specified as vectors of the following\\n  shape:\\n\\n      [context? ns-sym argument-resolvers? middleware? nested...?]\\n\\n  The optional fragments are interpreted as below:\\n\\n  context?\\n  : A context (a string, or a vector of strings and/or keywords) to be prepended to paths for all entries\\n  emitted for this namespace.\\n\\n  ns-sym\\n  : The symbol for the namespace that is to be mapped.\\n  : This is the only required value in the namespace specification.\\n\\n  argument-resolvers?\\n  : A map of argument resolvers that apply to the namespace, and to any child namespaces.\\n\\n  middleware?\\n  : Middleware to be applied to terminal handlers found in this\\n  namespace.\\n\\n  nested...?\\n  : Defines child namespaces, each its own recursive namespace specification.\\n  Child namespaces inherit the context, argument resolvers, and middleware\\n  of the containing namespace.\\n\\n  Supported options and their default values:\\n\\n  :arg-resolvers\\n  : Map of symbol to (keyword or function of request) or keyword\\n    to (function of symbol returning function of request). Entries of\\n    the former provide argument resolvers to be used when resolving\\n    arguments named by the given symbol; in the keyword case, a known\\n    resolver factory will be used.\\n  : Normally, the provided map is merged into the map inherited from\\n    the containing namespace (or elsewhere), but this can be controlled\\n    using metadata on the map.\\n  : Tag with {:replace true} to\\n    exclude inherited resolvers and resolver factories; tag with\\n    {:replace-resolvers true} or {:replace-factories true} to leave\\n    out default resolvers or resolver factories, respectively.\\n\\n  :context\\n  : _Default: []_\\n  : A root context that all namespaces are placed under, for example [\\\"api\\\"].\\n\\n  :default-middleware\\n  : _Default: [[default-namespace-middleware]]_\\n  : Default endpoint middleware applied to the basic handler for\\n    each endpoint function (the basic handler resolver arguments and passes\\n    them to the endpoint function).\\n    The default leaves the basic handler unchanged.\\n\\n  :swagger-options\\n  : Options to be passed to [[construct-swagger-object]], that control how the Swagger description is composed and\\n    customized.\\n    Swagger support is only enabled when :swagger-options is non-nil.\\n\\n  Example call:\\n\\n       (namespace-handler\\n         {:context            [\\\"api\\\"]\\n          :swagger-options    swagger/default-swagger-options\\n          :default-middleware custom-middleware\\n          :arg-resolvers      {'if-unmodified-since :header\\n                               'if-modified-since   :header}}\\n         ;; foo & bar use custom-middleware:\\n         [\\\"hotels\\\" 'org.example.resources.hotels\\n           [[:hotel-id \\\"rooms\\\"] 'org.example.resources.rooms]]\\n         [\\\"bars\\\" 'org.example.resources.bars]\\n         ;; taxis has special requirements:\\n         [\\\"taxis\\\" 'org.example.resources.taxis\\n           {:dispatcher dispatcher-resolver-factory}\\n           taxi-middleware]).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "resolve-argument-value" (dict "arglists" "([request argument-meta argument-symbol])" "doc" "\"Resolves an argument, as if it were an argument to an endpoint function.\\n\\n  request\\n  : The Ring request map, as passed through middleware and to the endpoint.\\n\\n  argument-meta\\n  : A map of metadata about the symbol, or a single keyword. A keyword is converted\\n    to a map (of the keyword, to true).\\n\\n  argument-symbol\\n  : A symbol identifying the name of the parameter. This is sometimes needed to construct\\n    the argument resolver function.\\n\\n  Throws an exception if no (single) argument resolver can be identified.\"") "wrap-with-injection" (dict "arglists" "([handler key value])" "doc" "\"Wraps a request handler with an injection of the key and value.\"") "wrap-with-injections" (dict "arglists" "([handler injections])" "doc" "\"Wraps a request handler with injections by merging in a map.\"") "wrap-with-standard-middleware" (dict "arglists" "([handler])" "doc" "\"The standard middleware that Rook expects to be present before it is passed the Ring request.\""))) "io.aviso.rook.server" (dict "aliases" (dict "io" "clojure.java.io" "l" "clojure.tools.logging" "medley" "medley.core" "rook" "io.aviso.rook" "str" "clojure.string" "t" "io.aviso.tracker" "utils" "io.aviso.rook.utils") "interns" (dict "cond-let" (dict "arglists" "([& forms])" "doc" "\"A merging of cond and let.  Each term is either a vector\\n  (in which case, it acts like let) or a condition expression followed by the value\\n  for that expression. An empty cond-let returns nil.\\n\\n  cond-let makes it possible to create readable code that doesn't end up nesting\\n  ;endlessly.\\n\\n  A typical example is where several steps must occur, perhaps reading data from\\n  an external datastore and making a few consistency checks:\\n\\n      (defn apply-payment [db-conn order-id user-id payment-info]\\n        (cond-let\\n          [order (find-order-by-id db-conn order-id)]\\n\\n          (nil? order)\\n          not-found-response\\n\\n          (not (owned-by? order user-id))\\n          forbidden-response\\n\\n          [existing-payment (find-payment db-conn (:payment-id order))]\\n\\n          (some? existing-payment)\\n          already-payed-response\\n\\n          :else\\n          (do\\n            (attach-payment db-conn order payment-info)\\n\\n            updated-response)))\"" "macro" "true") "construct-handler" (dict "arglists" "([{:keys [reload log debug track standard exceptions lazy]} creator & creator-args])" "doc" "\"Constructs a root handler using a creator function.  Normally, the creator function\\n  is invoked immediately, and returns a Ring handler function. However, during development,\\n  to take advantage of code reloading, the creator will be invoked on each incoming request.\\n\\n  To fully take advantage of REPL oriented development, you should pass the Var containing\\n  the creator function, e.g. `#'create-app-handler`.\\n\\n  The optional creator-args are additional arguments to be passed to the creator function;\\n  these are usually configuration data or dependencies.\\n\\n  The options map contains several flags:\\n\\n  :reload\\n  : enables the above-described reloading of the handler.\\n\\n  :lazy\\n  : if true (and :reload is false) then the handler is not created until first needed, rather\\n    then immediately on invoking this function.\\n\\n  :debug\\n  : enables logging (at debug level) of each incoming request via [[wrap-debug-request]]\\n    and [[wrap-debug-response]]\\n\\n  :log\\n  : enables logging of a summary of each incoming request (at info level) via [[wrap-log-request]].\\n\\n  :track\\n  : enables tracking a summary of each incoming request via [[wrap-track-request]].\\n\\n  :standard\\n  : Enables the standard Rook middleware, (see [[wrap-with-standard-middleware]]).\\n\\n  :exceptions\\n  : Enables [[wrap-with-exception-catching]] to catch and report exceptions.\\n\\n  The extra middleware is added around the root handler (or the\\n  reloading handler that creates the root handler).\"") "format-binary" (dict "arglists" "([data & options])" "doc" "\"Formats the data using [[write-binary]] and returns the result as a string.\"") "format-bytes" (dict "arglists" "([label byte-array])") "lazy-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created lazily on first access.\"") "log-request-and-body" (dict "arglists" "([request body-array])") "log-response" (dict "arglists" "([response])" "doc" "\"Logs the response at debug level (if enabled) with nice formatting; returns a new response (since reading\\n  an InputStream body is destructive).\"") "pretty-print" (dict "arglists" "([object])" "doc" "\"Pretty-prints the supplied object to a returned string.\"") "read-bytes" (dict "arglists" "([stream length])") "reloading-handler" (dict "arglists" "([creator])" "doc" "\"Wraps a handler creator function such that the root handler is created fresh on each request;\\n  this is used when developing the application as it supports re-loading of code in a REPL without having to\\n  restart the embedded Jetty instance.\"") "to-message" (dict "arglists" "([t])" "doc" "\"Converts an exception to a message. Normally, this is the message property of the exception, but if\\n  that's blank, the fully qualified class name of the exception is used instead.\"") "wrap-creator" (dict "arglists" "([creator creator-args])" "doc" "\"Wraps a creator and arguments as a function of no arguments. If the creator fails, then\\n  the error is logged and a handler that always responds with a 500 status is returned.\"") "wrap-debug-request" (dict "arglists" "([handler])" "doc" "\"Logs a pretty-printed representation of each incoming request, at level debug. This includes output\\n  of the body's content in ASCII and hex; this means that the entire body (if present) may be consumed\\n  and stored in memory, and replaced with a new InputStream downstream (when debugging is enabled).\"") "wrap-debug-response" (dict "arglists" "([handler])" "doc" "\"Used to log the response sent back to the client at debug level.\"") "wrap-log-request" (dict "arglists" "([handler])" "doc" "\"Logs incoming requests (as info), identifying method and URI.\"") "wrap-track-request" (dict "arglists" "([handler])" "doc" "\"An alternative to [[wrap-log-request]]; adds tracking with a label via [[summarize-request]].\"") "wrap-with-exception-catching" (dict "arglists" "([handler])" "doc" "\"A simple exception catching and reporting wrapper.\\n\\n   Establishes a tracking checkpoint (so it works very well with [[wrap-track-request]].\\n\\n   Exceptions are converted to 500 responses in the standard [[failure-response]] format.\""))) "json-window.core" ...) "id" "4" "repl-type" "clj" "session" "158b7cdb-12a9-4f87-8c96-8f6940cad593" "status" ("state")))
  nrepl-client-filter(#<process nrepl-connection> "output. This is\\nexactly equivalent to (pprint *1).\"5:macro4:truee6:pprintd8:arglists26:([object] [object writer])3:doc141:\"Pretty print object to the optional output writer. If the writer is not provided, \\nprint the object to the currently bound value of *out*.\"e3:pstd8:arglists27:([] [e-or-depth] [e depth])3:doc164:\"Prints a stack trace of the exception, to the depth requested. If none supplied, uses the root cause of the\\n  most recent repl exception (*e), and a depth of 12.\"e6:sourced8:arglists5:([n])3:doc211:\"Prints the source code for the given symbol, if it can find it.\\n  This requires that the symbol resolve to a Var defined in a\\n  namespace for which the .clj is in the classpath.\\n\\n  Example: (source filter)\"5:macro4:truee6:tracefd8:arglists45:([fmt & fmt-args] [throwable fmt & fmt-args])3:doc35:\"Trace level logging using format.\"5:macro4:trueeeee2:id1:59:repl-type3:clj7:session36:158b7cdb-12a9-4f87-8c96-8f6940cad5936:statusl5:stateee")