Respecting (or preferably imposing) _specific_ blanklines between forms

[riotrah]

Apologies if:

1. This has already been answered
2. This has been covered in the docs
3. The title isn't clear

I've tried looking around but am perhaps using the wrong keywords, and I've not seen any comparable features besides :respect-bl? for lists. Closest might be :fn-map { "fn-name" [:arg1 {:list {:respect-bl? true}}]}, but the following may illustrate my confusion:

For the following form:

(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)
    (testing "foo does foo"
      (is true)
    (testing "boo does boo"
      (is true))))

I'd like it to do the following:

(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)

    (testing "foo does foo"
      (is true)

    (testing "boo does boo"
      (is true))))

That is, a forced new blankline before each testing form. As an alternative, :respecting existing bls would be be nice. Just so long as other erroneous or non-testing bls are formatting normally as configured (eg removed if desired).

I think :fn-map { "testing" [:arg1 {:list {:respect-bl? true}}]} would only:

1. respect new lines, not add
2. only do so for all list elements descending from testing anyways

Similarly, doing the above but for deftest instead of testing, would (only) respect blank lines and would also do that for all descendents, not just testing (eg the let above wrapping the testings).

Any suggestions?

[kkinnear]

Good question, for which I think I have a good answer.

The example you gave didn't have balanced parentheses, and since testing allows nesting, it wasn't entirely clear how I should correct it. I turned your example into this:

(print i278)
(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)
    (testing "foo does foo"
      (is true))
    (testing "boo does boo"
      (is true))))

I hope that is what you wanted. If not, please be sure and let me know.

Just recently someone I'm working with wanted more blank lines between forms in a list. Which was a new one for me, but to enable some more complex things I added a basic capability to do this quite recently in 1.2.4, which will do pretty much exactly what I think you want.

Try this...

(print i278)
(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)
    (testing "foo does foo"
      (is true))
    (testing "boo does boo"
      (is true))))

(czprint i278 {:parse-string? true})
(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)
    (testing "foo does foo" (is true))
    (testing "boo does boo" (is true))))

(czprint i278 {:parse-string? true :fn-map {"deftest" [:arg1-body {:list {:nl-count 2}}]}})
(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)

    (testing "foo does foo" (is true))

    (testing "boo does boo" (is true))))

(czprint i278 {:parse-string? true :fn-map {"testing" :arg1-force-nl "deftest" [:arg1-body {:list {:nl-count 2}}]}})
(deftest foo-test
  (let [foo :bar]
    (some-fn-call :foo)

    (testing "foo does foo"
      (is true))

    (testing "boo does boo"
      (is true))))

I don't know exactly what you want to have happen in more complex examples, so give this a try in some realistic situations and see if it does what you want. If not, please let me know and we'll see what we can figure out. Actually, I would like to hear if it does what you want too! Thanks for asking. Lots of people get frustrated and don't bother to ask, which is too bad, since as hard as I've worked on the documentation, it is still pretty dense and there is a lot of it.

[riotrah]

Ahh sorry for the parens, the bane of my markdown sexp writing existence.

But yes! You've understood it perfectly! Thanks again for not only taking an interest but also for doing so crazy promptly as always. I'm not sure why you do it, but I hope it remains fun for you - zprint is freaking awesome and so are you!

Will try that out!