{:group-id "nubank", :artifact-id "state-flow", :version "5.16.0", :analysis {"clj" ({:name state-flow.api, :publics ({:name defflow, :file "state_flow/api.clj", :line 94, :arglists ([name & flows] [name parameters & flows]), :doc "Creates a flow and binds it a Var named by name\n", :type :macro} {:name flow, :file "state_flow/api.clj", :line 10, :arglists ([description & flows]), :doc "Creates a flow which is a composite of flows.\n", :type :macro} {:name fmap, :file "state_flow/api.clj", :line 84, :arglists ([f flow]), :doc "Creates a flow that returns the application of f to the return of flow\n", :type :var} {:name for, :file "state_flow/api.clj", :line 138, :arglists ([seq-exprs flow]), :doc "Like clojure.core/for, but returns a flow which wraps a sequence of flows e.g.\n\n  (flow \"even? returns true for even numbers\"\n    (flow/for [x (filter even? (range 10))]\n      (match? even? x)))\n\n  ;; same as\n\n(flow \"even? returns true for even numbers\"\n  (match? even? 0)\n  (match? even? 2)\n  (match? even? 4)\n  (match? even? 6)\n  (match? even? 8)) ", :type :macro} {:name get-state, :file "state_flow/api.clj", :line 126, :arglists ([] [f & args]), :doc "Creates a flow that returns the result of applying f (default identity)\nto state with any additional args.", :type :var} {:name ignore-error, :file "state_flow/api.clj", :line 58, :arglists ([pair]), :doc "No-op error handler that ignores the error.\n", :type :var} {:name invoke, :file "state_flow/api.clj", :line 63, :arglists ([my-fn]), :doc "Creates a flow that invokes a function of no arguments and returns the\nresult. Used to invoke side effects e.g.\n\n   (state-flow.core/invoke #(Thread/sleep 1000))", :type :var} {:name log-and-throw-error!, :file "state_flow/api.clj", :line 47, :arglists ([pair]), :deprecated true, :doc "DEPRECATED: Use (comp throw-error! log-error) instead. \n", :type :var} {:name match?, :file "state_flow/api.clj", :line 100, :arglists ([expected actual & [{:keys [times-to-try sleep-time], :as params}]]), :doc "Builds a state-flow step which uses matcher-combinators to make an\nassertion.\n\n`expected` can be a literal value or a matcher-combinators matcher\n`actual` can be a literal value, a primitive step, or a flow\n`params` are optional keyword-style args, supporting:\n\n  :times-to-try optional, default 1\n  :sleep-time   optional, millis to wait between tries, default 200\n\nGiven (= times-to-try 1), match? will evaluate `actual` just once.\n\nGiven (> times-to-try 1), match? will use `state-flow-probe/probe` to\nretry up to :times-to-try times, waiting :sleep-time between each try,\nand stopping when `actual` produces a value that matches `expected`.\n\nNOTE: when (> times-to-try 1), `actual` must be a step or a flow.\n\nReturns a map (in the left value) with information about the success\nor failure of the match, the details of which are used internally by\nstate-flow and subject to change.", :type :macro} {:name return, :file "state_flow/api.clj", :line 71, :arglists ([v]), :doc "Creates a flow that returns v. Use this as the last\nstep in a flow that you want to reuse in other flows, in\norder to clarify the return value, e.g.\n\n  (def increment-count\n    (flow \"increments :count and returns it\"\n      (state/modify update :count inc)\n      [new-count (state/gets :count)]\n      (state-flow/return new-count)))", :type :var} {:name run, :file "state_flow/api.clj", :line 16, :arglists ([flow] [flow initial-state]), :doc "Given an initial-state (default {}), runs a flow and returns a tuple of\nthe result of the last step in the flow and the end state.", :type :var} {:name run*, :file "state_flow/api.clj", :line 22, :arglists ([{:keys [init cleanup runner on-error fail-fast? before-flow-hook], :or {init (constantly {}), cleanup identity, runner run, fail-fast? false, before-flow-hook identity, on-error (comp throw-error! log-error (filter-stack-trace default-stack-trace-exclusions))}} flow]), :doc "Runs a flow with specified parameters. Use `run` unless you need\nthe customizations `run*` supports.\n\nSupported keys in the first argument are:\n\n  `:fail-fast?`       optional, default `false`, when set to `true`, the flow stops running after the first failing assertion\n  `:init`             optional, default (constantly {}), function of no arguments that returns the initial state\n  `:cleanup`          optional, default `identity`, function of the final state used to perform cleanup, if necessary\n  `:runner`           optional, default `run`, function of a flow and an initial state which will execute the flow\n  `:before-flow-hook` optional, default `identity`, function from state to new-state that is applied before excuting a flow, after flow description is updated.\n  `:on-error`         optional, function of the final result pair to be invoked when the first value in the pair represents an error, default:\n                      `(comp throw-error!\n                            log-error\n                            (filter-stack-trace default-stack-trace-exclusions))`", :type :var} {:name swap-state, :file "state_flow/api.clj", :line 131, :arglists ([f & args]), :doc "Creates a flow that replaces state with the result of applying f to\nstate with any additional args.", :type :var} {:name when, :file "state_flow/api.clj", :line 89, :arglists ([e flow]), :doc "Given an expression `e` and a flow, if the expression is logical true, return the flow. Otherwise, return nil in a monadic context.\n", :type :var}), :doc "This namespace provides the user API, that is, the set of public functions that one can use for writing flows.\n"} {:name state-flow.assertions.matcher-combinators, :publics ({:name match?, :file "state_flow/assertions/matcher_combinators.clj", :line 25, :arglists ([expected actual & [{:keys [times-to-try sleep-time], :as params}]]), :doc "Builds a state-flow step which uses matcher-combinators to make an\nassertion.\n\n`expected` can be a literal value or a matcher-combinators matcher\n`actual` can be a literal value, a primitive step, or a flow\n`params` are optional keyword-style args, supporting:\n\n  :times-to-try optional, default 1\n  :sleep-time   optional, millis to wait between tries, default 200\n\nGiven (= times-to-try 1), match? will evaluate `actual` just once.\n\nGiven (> times-to-try 1), match? will use `state-flow-probe/probe` to\nretry up to :times-to-try times, waiting :sleep-time between each try,\nand stopping when `actual` produces a value that matches `expected`.\n\nNOTE: when (> times-to-try 1), `actual` must be a step or a flow.\n\nReturns a map (in the left value) with information about the success\nor failure of the match, the details of which are used internally by\nstate-flow and subject to change.", :type :macro} {:name report->actual, :file "state_flow/assertions/matcher_combinators.clj", :line 91, :arglists ([report]), :doc "Returns the actual value from the report returned by `match?`.\n", :type :var})} {:name state-flow.assertions.report, :publics ({:name push, :file "state_flow/assertions/report.clj", :line 7, :arglists ([assertion-report]), :type :var})} {:name state-flow.cljtest, :publics ({:name defflow, :file "state_flow/cljtest.clj", :line 41, :arglists ([name & flows] [name parameters & flows]), :doc "Creates a flow and binds it a Var named by name\n", :type :macro} {:name match?, :file "state_flow/cljtest.clj", :line 11, :arglists ([match-desc actual expected & [params]]), :deprecated true, :doc "DEPRECATED. Use state-flow.assertions.matcher-combinators/match? instead. \n", :type :macro})} {:name state-flow.core, :publics ({:name annotate-with-line-meta, :file "state_flow/core.clj", :line 157, :arglists ([flows]), :type :var} {:name apply-before-flow-hook, :file "state_flow/core.clj", :line 141, :arglists ([]), :type :var} {:name as-step-fn, :file "state_flow/core.clj", :line 215, :arglists ([flow]), :deprecated true, :doc "DEPRECATED with no replacement.\n", :type :var} {:name current-description, :file "state_flow/core.clj", :line 117, :arglists ([]), :doc "Returns a flow that returns the description as of the point of execution.\n\nFor internal use. Subject to change.", :type :var} {:name deep-stack-trace-filter!, :file "state_flow/core.clj", :line 278, :arglists ([ex exclusions]), :type :var} {:name default-stack-trace-exclusions, :file "state_flow/core.clj", :line 257, :type :var} {:name description->file, :file "state_flow/core.clj", :line 57, :arglists ([{:keys [file]}]), :type :var} {:name description-stack, :file "state_flow/core.clj", :line 95, :arglists ([s]), :doc "Returns the list of descriptions in the current stack.\n\nExample:\n(description-stack s)\n;; =>\n[{:description \"my test\"\n  :file \"my-test-file.clj\"\n  :line 42}]", :type :var} {:name fail-fast?, :file "state_flow/core.clj", :line 128, :doc "Should the flow stop after the first failing assertion?\n\nFor internal use. Subject to change.", :type :var} {:name filter-stack-trace, :file "state_flow/core.clj", :line 285, :arglists ([] [exclusions]), :doc "Returns an error handler which, if the first element in the pair is\na failure, returns the pair with the failure's stack-trace\nfiltered, else returns the pair as/is.\n\nexclusions (default default-stack-trace-exclusions) is a sequence of\nregular expressions used to match class names in stack trace frames.\nMatching frames are excluded.", :type :var} {:name flow, :file "state_flow/core.clj", :line 199, :arglists ([description & flows]), :doc "Creates a flow which is a composite of flows.\n", :type :macro} {:name flow*, :file "state_flow/core.clj", :line 172, :arglists ([{:keys [description caller-meta]} & flows]), :doc "For use in macros that create flows. Not private (appropriate for\nhelper libraries, for example), but not intended for use directly in\nflows.\n\nCreates a flow which is a composite of flows. The calling macro should\nprovide (meta &form) as `:caller-meta` in order to support accurate line\nnumber reporting.", :type :var} {:name format-description, :file "state_flow/core.clj", :line 88, :arglists ([stack]), :type :var} {:name ignore-error, :file "state_flow/core.clj", :line 229, :arglists ([pair]), :doc "No-op error handler that ignores the error.\n", :type :var} {:name log-and-throw-error!, :file "state_flow/core.clj", :line 252, :arglists ([pair]), :deprecated true, :doc "DEPRECATED: Use (comp throw-error! log-error) instead. \n", :type :var} {:name log-error, :file "state_flow/core.clj", :line 234, :arglists ([pair]), :doc "Error handler that logs error and returns pair.\n", :type :var} {:name modify-meta, :file "state_flow/core.clj", :line 24, :arglists ([f & args]), :doc "Returns a monad that will apply vary-meta to the world.\n\nFor internal use. Subject to change.", :type :var} {:name pop-meta, :file "state_flow/core.clj", :line 46, :arglists ([]), :doc "Returns a flow that will modify the state metadata.\n\nFor internal use. Subject to change.", :type :var} {:name push-meta, :file "state_flow/core.clj", :line 31, :arglists ([description {:keys [line ns file call-site-meta]}]), :doc "Returns a flow that will modify the state metadata.\n\nFor internal use. Subject to change.", :type :var} {:name run, :file "state_flow/core.clj", :line 315, :arglists ([flow] [flow initial-state]), :doc "Given an initial-state (default {}), runs a flow and returns a tuple of\nthe result of the last step in the flow and the end state.", :type :var} {:name run!, :file "state_flow/core.clj", :line 368, :arglists ([flow] [flow initial-state]), :deprecated true, :doc "DEPRECATED. Use `run*`\n", :type :var} {:name run*, :file "state_flow/core.clj", :line 326, :arglists ([{:keys [init cleanup runner on-error fail-fast? before-flow-hook], :or {init (constantly {}), cleanup identity, runner run, fail-fast? false, before-flow-hook identity, on-error (comp throw-error! log-error (filter-stack-trace default-stack-trace-exclusions))}} flow]), :doc "Runs a flow with specified parameters. Use `run` unless you need\nthe customizations `run*` supports.\n\nSupported keys in the first argument are:\n\n  `:fail-fast?`       optional, default `false`, when set to `true`, the flow stops running after the first failing assertion\n  `:init`             optional, default (constantly {}), function of no arguments that returns the initial state\n  `:cleanup`          optional, default `identity`, function of the final state used to perform cleanup, if necessary\n  `:runner`           optional, default `run`, function of a flow and an initial state which will execute the flow\n  `:before-flow-hook` optional, default `identity`, function from state to new-state that is applied before excuting a flow, after flow description is updated.\n  `:on-error`         optional, function of the final result pair to be invoked when the first value in the pair represents an error, default:\n                      `(comp throw-error!\n                            log-error\n                            (filter-stack-trace default-stack-trace-exclusions))`", :type :var} {:name runner, :file "state_flow/core.clj", :line 220, :arglists ([]), :doc "Creates a flow that returns the runner (function). Useful for\nhelpers that need to access the runner.", :type :var} {:name throw-error!, :file "state_flow/core.clj", :line 242, :arglists ([pair]), :doc "Error handler that throws the error.\n", :type :var} {:name top-level-description, :file "state_flow/core.clj", :line 209, :arglists ([s]), :doc "Returns the description passed to the top level flow (or the\nstringified symbol passed to defflow).", :type :var})} {:name state-flow.internals.description, :publics ({:name abbr-sexpr, :file "state_flow/internals/description.clj", :line 17, :arglists ([expr]), :type :var})} {:name state-flow.labs.cljtest, :publics ({:name testing, :file "state_flow/labs/cljtest.clj", :line 6, :arglists ([desc & body]), :doc "state-flow's equivalent to clojure test's `testing`\n", :type :macro})} {:name state-flow.labs.state, :publics ({:name with-redefs, :file "state_flow/labs/state.clj", :line 22, :arglists ([bindings & flows]), :doc "WARNING: `with-redefs` usage is not recommended. Use only if you know what you're\ndoing and you are sure you can't achieve the same result without it.\n\nWraps the provided state-flow execution with `clojure.core/with-redefs`\nmacro, e.g.\n\n  (defn now [] (java.util.Date.))\n  (def flow-with-trapped-time\n    (labs.state/with-redefs\n      [now (constantly #inst \"2018-01-01\")]\n      (flow \"a flow in 2018\"\n            ...)))", :type :macro} {:name wrap-with, :file "state_flow/labs/state.clj", :line 8, :arglists ([wrapper-fn flow]), :doc "WARNING: `wrap-with` usage is not recommended. Use only if you know what you're\ndoing and you are sure you can't achieve the same result without it.\n\nWraps the provided state-flow execution. `wrapper-fn` will be passed a\nfunction that will run the flow when called.", :type :macro}), :doc "WARNING: This API is experimental and subject to changes.\n"} {:name state-flow.midje, :publics ({:name add-desc-and-meta, :file "state_flow/midje.clj", :line 10, :arglists ([[fname & rest] desc meta]), :type :macro} {:name verify, :file "state_flow/midje.clj", :line 23, :arglists ([desc left-value right-value]), :doc "If left-value is a state, do fact probing. Otherwise, regular fact checking.\nPush and pop descriptions (same behaviour of flow)", :type :macro} {:name verify-probe, :file "state_flow/midje.clj", :line 14, :arglists ([desc state right-value metadata]), :doc "Given a fact description, a state and a right-value,\nreturns a State that runs left up to times-to-retry times every sleep-time ms until left-value equals right value.", :type :macro})} {:name state-flow.probe, :publics ({:name default-sleep-time, :file "state_flow/probe.clj", :line 9, :type :var} {:name default-times-to-try, :file "state_flow/probe.clj", :line 10, :type :var} {:name probe, :file "state_flow/probe.clj", :line 39, :arglists ([step check-fn] [step check-fn {:keys [sleep-time times-to-try], :or {sleep-time default-sleep-time, times-to-try default-times-to-try}}]), :doc "Internal use only. Evaluates step repeatedly with check-fn until check-fn succeeds or we try too many times\n", :type :var})} {:name state-flow.refactoring-tools.refactor-match, :publics ({:name form-starting-with, :file "state_flow/refactoring_tools/refactor_match.clj", :line 161, :arglists ([zloc val]), :type :var} {:name match-expr?, :file "state_flow/refactoring_tools/refactor_match.clj", :line 63, :arglists ([match-sym node]), :type :var} {:name probe-params, :file "state_flow/refactoring_tools/refactor_match.clj", :line 9, :arglists ([orig]), :type :var} {:name refactor!, :file "state_flow/refactoring_tools/refactor_match.clj", :line 250, :arglists ([{:keys [path str rewrite wrap-in-flow], :as opts}]), :type :var} {:name refactor-match-expr, :file "state_flow/refactoring_tools/refactor_match.clj", :line 21, :arglists ([{:keys [wrap-in-flow force-probe-params sym-after]} zloc]), :doc "If there is an exception, printlns the expression so you can\nfind and handle it manually.", :type :var} {:name refactor-match-exprs, :file "state_flow/refactoring_tools/refactor_match.clj", :line 68, :arglists ([{:keys [path str z sym-before sym-after rewrite wrap-in-flow force-probe-params], :as opts}]), :doc "Given a map with a zipper :z, :path to a file or a string :str, returns\na string with all of the match? expressions refactored as follows:\n\nGiven a match? expression e.g.\n\n  (match? <description> <actual> <expected>)\n  ;; or\n  (match? <description> <actual> <expected> <params>)\n\nReturns an expect expression e.g.\n\n  (match? <expected> <actual>)\n  ;; or\n  (match? <expected> <actual> <params>)\n\nWith :wrap-in-flow set to true, returns e.g.\n\n  (flow <description> (match? <expected> <actual>))\n  ;; or\n  (flow <description> (match? <expected> <actual> <params>))\n\nSupported keys:\n- :str                 this or path are required   - string source for the refactoring\n- :path                this or str are required    - path to source for refactoring\n- :rewrite             optional (default false)    - rewrites refactored code to the same path\n- :sym-before          optional (default `match?`) - symbol to look for for match? expressions\n                         - use this key if you've got a qualified symbol\n- :sym-after           optional (default `match?`) - symbol to replace :sym-before\n- :wrap-in-flow        optional (default false)    - set to true to wrap in a flow with the description\n                                                     from the source match? expression\n- :force-probe-params  optional (default false)    - makes probe params explicit (strongly recommended)\n\nThis is intended to help you in refactoring to the new match? function, however\nthere are some things you'll need to do on your own:\n\n- before\n  - ensure that the the `match?` expressions you wish to refactor use the same\n    symbol (simple or qualified) before refactoring\n- after\n  - reformat for whitespace (manually or w/ cljfmt)\n- before or after\n  - update the ns declaration to include state-flow.assertions.matcher-combinators\n    - if :sym-after is simple i.e. just `match?`, then `:refer [match?]`\n    - if :sym-after is qualified, then use `:as <alias>`\n\nWARNING: the old version of match? probes implicitly when `actual` is a step. The new\nversion requires an explicit `{:times-to-try <value gt 1>}` to trigger polling, so\nleaving out :force-probe-params may result in tests failing because they need probe.", :type :var} {:name refactor-ns-dec, :file "state_flow/refactoring_tools/refactor_match.clj", :line 225, :arglists ([{:keys [z rewrite wrap-in-flow], :as opts}]), :doc "Given a map with :path to a file or a string :str, returns\na zipper with all of the ns declarations refactored as follows:\n\nGiven an ns declaration with this in require:\n\n  [state-flow.cljtest :refer [match?]]\n\nRefactor it to\n\n  [state-flow.assertions.matcher-combinators :refer [match?]]\n\nIf `:wrap-in-flow` is true, then ensures that this line is in\nthe ns declaration\n\n  [state-flow.core :refer [flow]]\n", :type :var} {:name refactor-refer-match, :file "state_flow/refactoring_tools/refactor_match.clj", :line 211, :arglists ([opts zloc]), :type :var} {:name refactor-refer-match*, :file "state_flow/refactoring_tools/refactor_match.clj", :line 195, :arglists ([zloc]), :type :var} {:name refer?, :file "state_flow/refactoring_tools/refactor_match.clj", :line 142, :arglists ([zloc sym]), :type :var} {:name replace-value, :file "state_flow/refactoring_tools/refactor_match.clj", :line 16, :arglists ([zloc]), :type :var} {:name require-cljtest-refer-match?, :file "state_flow/refactoring_tools/refactor_match.clj", :line 151, :arglists ([zloc]), :doc "Returns true if zloc represents a require vector with\n- state-flow.cljtest\n- :refer [match?] (not necessarily only match)", :type :var} {:name require-form, :file "state_flow/refactoring_tools/refactor_match.clj", :line 166, :arglists ([zloc]), :type :var} {:name require-state-flow-core-form, :file "state_flow/refactoring_tools/refactor_match.clj", :line 169, :arglists ([zloc]), :type :var} {:name require-state-flow-core-refer-flow, :file "state_flow/refactoring_tools/refactor_match.clj", :line 218, :arglists ([opts zloc]), :type :var} {:name require-state-flow-core-refer-flow*, :file "state_flow/refactoring_tools/refactor_match.clj", :line 172, :arglists ([zloc]), :type :var}), :doc "This ns contains tools to refactor from match? in the cljtest\nns to the new version in the assertions.matcher-combinators ns."} {:name state-flow.state, :publics ({:name ensure-step, :file "state_flow/state.clj", :line 141, :arglists ([value]), :doc "Internal use only.\n\nGiven a state-flow step, returns value as/is, else wraps value in a state-flow step.", :type :var} {:name error-catching-state, :file "state_flow/state.clj", :line 17, :arglists ([mfn]), :type :var} {:name eval, :file "state_flow/state.clj", :line 138, :type :var} {:name exec, :file "state_flow/state.clj", :line 139, :type :var} {:name fmap, :file "state_flow/state.clj", :line 120, :arglists ([f flow]), :doc "Creates a flow that returns the application of f to the return of flow\n", :type :var} {:name get, :file "state_flow/state.clj", :line 68, :arglists ([]), :doc "Creates a flow that returns the value of state. \n", :type :var} {:name gets, :file "state_flow/state.clj", :line 73, :arglists ([] [f & args]), :doc "Creates a flow that returns the result of applying f (default identity)\nto state with any additional args.", :type :var} {:name invoke, :file "state_flow/state.clj", :line 105, :arglists ([my-fn]), :doc "Creates a flow that invokes a function of no arguments and returns the\nresult. Used to invoke side effects e.g.\n\n   (state-flow.core/invoke #(Thread/sleep 1000))", :type :var} {:name modify, :file "state_flow/state.clj", :line 86, :arglists ([f & args]), :doc "Creates a flow that replaces state with the result of applying f to\nstate with any additional args.", :type :var} {:name put, :file "state_flow/state.clj", :line 81, :arglists ([new-state]), :doc "Creates a flow that replaces state with new-state. \n", :type :var} {:name return, :file "state_flow/state.clj", :line 92, :arglists ([v]), :doc "Creates a flow that returns v. Use this as the last\nstep in a flow that you want to reuse in other flows, in\norder to clarify the return value, e.g.\n\n  (def increment-count\n    (flow \"increments :count and returns it\"\n      (state/modify update :count inc)\n      [new-count (state/gets :count)]\n      (state-flow/return new-count)))", :type :var} {:name run, :file "state_flow/state.clj", :line 137, :type :var} {:name short-circuiting-context, :file "state_flow/state.clj", :line 26, :doc "Same as state monad context, but short circuits if error happens, place error in return value\n", :type :var} {:name state?, :file "state_flow/state.clj", :line 136, :type :var} {:name swap, :file "state_flow/state.clj", :line 126, :arglists ([f]), :deprecated true, :doc "DEPRECATED: use state-flow.state/modify instead.\n", :type :var} {:name when, :file "state_flow/state.clj", :line 113, :arglists ([e flow]), :doc "Given an expression `e` and a flow, if the expression is logical true, return the flow. Otherwise, return nil in a monadic context.\n", :type :var} {:name wrap-fn, :file "state_flow/state.clj", :line 131, :deprecated true, :doc "DEPRECATED: Use state-flow.state/invoke instead.\n", :type :var})})}, :pom-str "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0</modelVersion>\n  <groupId>nubank</groupId>\n  <artifactId>state-flow</artifactId>\n  <packaging>jar</packaging>\n  <version>5.16.0</version>\n  <name>state-flow</name>\n  <description>Integration testing with composable flows</description>\n  <url>https://github.com/nubank/state-flow</url>\n  <licenses>\n    <license>\n      <name>MIT</name>\n    </license>\n  </licenses>\n  <scm>\n    <url>https://github.com/nubank/state-flow</url>\n    <connection>scm:git:git://github.com/nubank/state-flow.git</connection>\n    <developerConnection>scm:git:ssh://git@github.com/nubank/state-flow.git</developerConnection>\n    <tag>e1fff3dc32d94ff45a121c5f6d9d3bec3c151259</tag>\n  </scm>\n  <build>\n    <sourceDirectory>src</sourceDirectory>\n    <testSourceDirectory>test</testSourceDirectory>\n    <resources>\n      <resource>\n        <directory>resources</directory>\n      </resource>\n    </resources>\n    <testResources>\n      <testResource>\n        <directory>resources</directory>\n      </testResource>\n    </testResources>\n    <directory>target</directory>\n    <outputDirectory>target/classes</outputDirectory>\n    <plugins/>\n  </build>\n  <repositories>\n    <repository>\n      <id>central</id>\n      <url>https://repo1.maven.org/maven2/</url>\n      <snapshots>\n        <enabled>false</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n    <repository>\n      <id>clojars</id>\n      <url>https://repo.clojars.org/</url>\n      <snapshots>\n        <enabled>true</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n    <repository>\n      <id>publish</id>\n      <url>https://clojars.org/repo</url>\n      <snapshots>\n        <enabled>true</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n  </repositories>\n  <dependencyManagement>\n    <dependencies/>\n  </dependencyManagement>\n  <dependencies>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojure</artifactId>\n      <version>1.11.1</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>com.taoensso</groupId>\n      <artifactId>timbre</artifactId>\n      <version>4.10.0</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>funcool</groupId>\n      <artifactId>cats</artifactId>\n      <version>2.4.2</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>nubank</groupId>\n      <artifactId>matcher-combinators</artifactId>\n      <version>3.5.0</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n    </dependency>\n    <dependency>\n      <groupId>ns-tracker</groupId>\n      <artifactId>ns-tracker</artifactId>\n      <version>0.4.0</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>tools.namespace</artifactId>\n      <version>1.2.0</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>midje</groupId>\n      <artifactId>midje</artifactId>\n      <version>1.10.9</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>java.classpath</artifactId>\n      <version>1.0.0</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n      <scope>test</scope>\n    </dependency>\n    <dependency>\n      <groupId>rewrite-clj</groupId>\n      <artifactId>rewrite-clj</artifactId>\n      <version>0.6.1</version>\n      <exclusions>\n        <exclusion>\n          <artifactId>log4j</artifactId>\n          <groupId>log4j</groupId>\n        </exclusion>\n      </exclusions>\n      <scope>test</scope>\n    </dependency>\n  </dependencies>\n</project>\n\n<!-- This file was autogenerated by Leiningen.\n  Please do not edit it directly; instead edit project.clj and regenerate it.\n  It should not be considered canonical data. For more information see\n  https://codeberg.org/leiningen/leiningen -->\n"}