How to force wrapping for constant pairing?

[agriffis]

I love zprint and I believe its configuration is very powerful, and yet I still struggle with flows, hangs and wrapping...

I am using this incantation from #56 (comment)

{:fn-map {"app" [:none {:style [:moustache :justified]}]}}

I would like output like this:

(def handler
  (m/app
    ["api" &]      query-app
    ["path-api" &] query-app))

but I get this instead:

(def handler (m/app ["api" &] query-app ["path-api" &] query-app))

I wouldn't mind this:

(def handler (m/app ["api" &]      query-app
                    ["path-api" &] query-app))

or this:

(def handler
  (m/app ["api" &]      query-app
         ["path-api" &] query-app))

I just don't want it to put two pairs on one line, even if it would fit.

Generally I really like the fact that zprint will fit things if it can, but there are occasions when I'd rather see a linebreak, even if it would fit. This is one of those occasions...

[kkinnear]

Aron, While I think I can do exactly what you want, I can't get to it until tomorrow. If you put this into your .zprintrc (or somewhere), and use this new style, it will do most of what you want. You can't define the style and use it in the same zprintrc, unfortunately. {:style-map {:m2 {:fn-map {"app" [:force-nl-body {:list {:constant-pair-min 1, :constant-pair-fn #(or (keyword? %) (string? %) (number? %) (= true %) (= false %) (vector? %))}, :pair {:justify? true}, :next-inner {:list {:constant-pair-min 4, :constant-pair-fn nil}, :pair {:justify? false}}}]}}}} More later...

…

On Dec 10, 2020, at 1:28 PM, Aron Griffis ***@***.***> wrote: I love zprint and I believe its configuration is very powerful, and yet I still struggle with flows, hangs and wrapping... I am using this incantation from #56 (comment) {:fn-map {"app" [:none {:style [:moustache :justified]}]}} I would like output like this: (def handler ( m/app [ "api" &] query-app [ "path-api" &] query-app)) but I get this instead: (def handler (m/app ["api" &] query-app ["path-api" &] query-app)) I wouldn't mind this: (def handler (m/app ["api" &] query-app [ "path-api" &] query-app)) or this: (def handler ( m/app ["api" &] query-app [ "path-api" &] query-app)) I just don't want it to put two pairs on one line, even if it would fit. Generally I really like the fact that zprint will fit things if it can, but there are occasions when I'd rather see a linebreak, even if it would fit. This is one of those occasions... — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or unsubscribe.

[agriffis]

Thank you, Kim. Looking forward to hearing what you have in mind, but no rush.

[kkinnear]

Thanks for finding the discussions!

I am making changes in 1.1.0 that will make it very straightforward to get what you want. In particular, you will be able to use functions in options maps in an .zprinrtrc or .zprint.edn file, and you will be able to use them with the distributed graalVM binaries as well. I have integrated sci and it works great, thus making all of this very much easier. But let's see what we can do for you today...

For now, in 1.0.2, there are two answers -- one for the distributed binaries, and one for using lein zprint or the uberjar. I don't know which one you use.

If you use the distributed graalVM binaries, here is the best I can do for you in 1.0.2. This is a real hack and doesn't fully give you what you want, but it will help a least a bit.

; Put this in your ~/.zprintrc

{:fn-force-nl #{:none} :style :moustache}

; Then you will get

$ ./zprintm-1.0.2 <hand.clj
(def handler
  (m/app ["api" &] query-app
         ["path-api" &] query-app))

 $ ./zprintm-1.0.2 <mapp9.clj
(m/app :get (m/app middle1
                   middle2
                   middle3
                   [route] handler
                   [longer route]
                     (handler this is "a" test "this" is "only a" test))
       ; How do comments work here?
       true (should be paired with true)
       false (should be paired with false)
       6 (should be paired with 6)
       "string" (should be paired with string)
       :post (m/app [a really long route] handler
                    [route] handler))

This wasn't justified, I know. If you want them justified, then you have to put up with all pairs being justified. That is mostly cond and assoc things, not let bindings or maps.

; Put this in your ~/.zprintrc`

{:fn-force-nl #{:none} :style :moustache :pair {:justify? true}}

$ ./zprintm-1.0.2 <hand.clj
(def handler
  (m/app ["api" &]      query-app
         ["path-api" &] query-app))

$ ./zprintm-1.0.2 <mapp9.clj
(m/app :get     (m/app middle1
                       middle2
                       middle3
                       [route] handler
                       [longer route]
                         (handler this is "a" test "this" is "only a" test))
       ; How do comments work here?
       true     (should be paired with true)
       false    (should be paired with false)
       6        (should be paired with 6)
       "string" (should be paired with string)
       :post    (m/app [a really long route] handler
                       [route]               handler))

If, instead, you are using lein zprint or the uberjar, then things are a little better.

; Put this in your .zprintrc
{:fn-map {"app" [:force-nl
                 {:list {:constant-pair-fn #(or (keyword? %)
                                                (string? %)
                                                (number? %)
                                                (= true %)
                                                (= false %)
                                                (vector? %)),
                         :constant-pair-min 1},
                  :next-inner {:list
                                 {:constant-pair-fn nil, :constant-pair-min 4},
                               :pair {:justify? false}},
                  :pair {:justify? true}}]}}

; Then you get

$ java -jar ~/bin/zprint-filter-1.0.2 <hand.clj
(def handler
  (m/app ["api" &]      query-app
         ["path-api" &] query-app))

$ java -jar ~/bin/zprint-filter-1.0.2 <mapp9.clj 
(m/app :get     (m/app middle1
                       middle2
                       middle3
                       [route] handler
                       [longer route]
                         (handler this is "a" test "this" is "only a" test))
       ; How do comments work here?
       true     (should be paired with true)
       false    (should be paired with false)
       6        (should be paired with 6)
       "string" (should be paired with string)
       :post    (m/app [a really long route] handler
                       [route]               handler))

; The justification here is just for "app", and doesn't affect anything inside the handlers for "app" 
; or anything else in the file -- just the top level of "app"

; Oh, yes, lein zprint uses the uberjar (essentially), which is what I was doing above.  Here it is for real

$ lein zprint mapp9.clj
Processing file: mapp9.clj
$ more mapp9.clj
(m/app :get     (m/app middle1
                       middle2
                       middle3
                       [route] handler
                       [longer route]
                         (handler this is "a" test "this" is "only a" test))
       ; How do comments work here?
       true     (should be paired with true)
       false    (should be paired with false)
       6        (should be paired with 6)
       "string" (should be paired with string)
       :post    (m/app [a really long route] handler
                       [route]               handler))

In 1.1.0, the above will work for the distributed graalVM binaries as well.

At present, there is no way to get "m/app" to put the next things on the next line and have constant pairing work. I will be changing that in 1.1.0 because of this conversation, so I'm glad you brought this up. Thus, in 1.1.0, the :flow fn-type will also support constant pairing.

One further note. I think that I might have erred in defining the :moustache style as affecting the :fn-map for app. This makes it really hard to slightly change. It is really confusing to have {:fn-type {"app" [:force-nl {:style :moustache}]}} because this wipes out the whole constant pairing thing in the style map for :moustache which is associated with the :fn-type of "app" to begin with. There may be some way to break this up so that it is easier to process conceptually and work with practically, but I'm not clear yet on how I might do that.

I think that I will keep a style which does what I think you want, called :moustache, but if (when) you want to tweak it, the way that you will tweak it will be to put the whole thing in your .zprintrc file and not reference the style at all like I did for the example for lein zprint above. This will work because, as of 1.1.0, you can have functions in options maps anywhere and with any binary.

I'm still pondering how to have someone tweak a style by changing the style map and then invoke that tweaked style in the same .zprintrc -- because I explicitly invoke the style prior to dealing with the rest of the options map, so people can override the elements of the style in the same option map. This makes it hard to define a new or changed style and invoke it in the same options map. But that is a problem for later.

Anyway, I hope this help. What will really help will be the changes I'm making in 1.1.0.

Oh, thanks also for mentioning in Issue #56 that zprint ignored your options maps with issues without visible complaint. Turns out that options maps found with :search-config? true were checked for problems, but the errors were lost. Actually two bugs which have been in there since I initially implemented :search-config? years ago. It was great to find and fix those. I'm in the middle of making tests for those problem so they don't recur.

Let me know how this goes if you can.

[agriffis]

Wow Kim. I hope you enjoy working on zprint, because you truly go above and beyond helping people use it.

Your examples here worked for me, though I'm limited by using the binaries instead of lein zprint or the uberjar. I am really looking forward to the sci-based config loader so I can try your larger examples.

Thanks again!

[kkinnear]

I released 1.1.0 yesterday. The {:style :moustache} should do what you want.

(czprint mapp {:parse-string? true})
(def handler (m/app ["api" &] query-app ["path-api" &] query-app))
nil
(czprint mapp {:parse-string? true :style :moustache})
(def handler
  (m/app
    ["api" &]      query-app
    ["path-api" &] query-app))

I did also make it possible to define a :style and then to use it in the same .zprintrc or whatever. I also broke up the :moustache style so that it depends on another style called :vector-pairs, so that it is easier to change and reuse in different places. In case you wanted to use it with something besides m/app, for instance. I also made it possible to define fns in option maps anywhere, including the graalVM binaries by using sci, which worked out pretty well in the end.

Overall, I think it will just work for you, but if it doesn't, there certainly are multiple ways of adjusting what is there without requiring a new release to make it better.

Thanks for pursuing this, it encouraged me to take on a lot of cleanup that I wouldn't otherwise have been motivated to accomplish!