If I were to be able to use a debugger, in the way that I debug code for other languages, I would be placing a breakpoint inside the function that receives the path, but I'm unfamiliar with Cursive debugger, and also not even sure if I should be using that.

For reference, this is my script here: https://github.com/amitnovick/bookmark-files-combiner/blob/main/src/bookmark_files_combiner/core.clj

> As a newbie in debugging Clojure code, and babashka code in particular, my first reaction was to try and tweak the script to receive that same path "hard-coded" instead of receiving it as a command line argument, and try to fix the bug through inspection etc. Yes, I think this approach is good. Just call your function with the input which triggers the error in the REPL and then narrow down the issue.

@U04V15CAJ I believe that the issue stems from this line here or some subsequent line: https://github.com/amitnovick/bookmark-files-combiner/blob/main/src/bookmark_files_combiner/core.clj#L134

Is there a way to save the previous result before continuing to perform the rest of the function?

I'm referring to the already generated values inside the let form. I'd want to be able to do part of the content in it, and use the vars again

all this without having to re-send the entire let form every time

Guess I could just def those vars outside the let clause

work outside the let form in the namespace scope

indeed. what people use for this is a comment form in the namespace

and then you can evaluated (def whatever (my-function ...)) in the comment form

if you haven't already I recommend reading this: https://clojure.org/guides/repl/introduction

I'll be sure to check it out sometime

Regarding the comment, what is the purpose of that in short?

the purpose is that you can write your REPL expressions in there and evaluate them from your editor, without executing them when the program is called

;; scratch 
(comment
  (def x (+ 1 2 3)) ;;=> 3
)  

well but I'm not re-running the script

I know, but at some point you will

and then it's not so nice when you have top level expressions that do stuff

Oh so you mean people use those comment forms just so they don't have to clean it up afterwards?

because I was gonna do the work outside the let clause and just put it back in there and remove the defs after that

yeah, that's the idea, also to give some people an idea how you can call things

@U04V15CAJ I don't quite understand how comment helps me for debugging

I could just comment things out with ; just the same, couldn't I?

for reference, I'm now trying to debug this function here that gets called from the let clause

(defn merge-pdfs [output-combined-pdf-path pdf-files]
  (shell (str/join " " ["pdftk",
                        (str/join " "
                                  (map
                                    (fn [pdf-file-path]
                                      (str pdf-file-path)
                                      )
                                    pdf-files
                                    )),
                        "cat",
                        "output",
                        output-combined-pdf-path
                        ]))
  )

it's right here: https://github.com/amitnovick/bookmark-files-combiner/blob/main/src/bookmark_files_combiner/core.clj#L94

Now I wish to evaluate the (str/join) form inside the function, once it gets invoked (by being sent to the REPL)

Is there a way to debug this without messing with my code too much?

In other languages, I would just put a debugger on a line inside the function and evaluate the values at that point in time

So in the end I just changed the inside of the function so that instead of calling the shell immediately, I just return the value of (str/join) and was able to inspect it afterwards. Turns out the bug fix was that I had to add single-quotes to every file name to avoid whitespace being interpreted by the shell as separate arguments. The change was a one-liner, so I just copied it, reset my git back to previous state and pasted it in :rolling_on_the_floor_laughing:

> So in the end I just changed the inside of the function so that instead of calling the shell immediately, I just return the value of (str/join) and was able to inspect it afterwards. 👍 > Turns out the bug fix was that I had to add single-quotes to every file name to avoid whitespace being interpreted by the shell as separate arguments. 👎

I already told you many times that you can supply separate string arguments to shell. There is no need to escape those with single quotes, just do not concatenate them :)

:thinking_face:

You did in fact say that

(defn merge-pdfs [output-combined-pdf-path pdf-files]
  (apply shell "pdftk" ["file1" "file2" "file3"]))

I think something like this should work:

(defn merge-pdfs [output-combined-pdf-path pdf-files]
  (apply shell "pdftk" (concat (map str pdf-files) ["cat" "output" output-combined-pdf-path])))

I think map str isn't even necessary since shell will already call str on the arguments

@U04V15CAJ your code works 🙂

I tried to embrace what you taught and made another version kinda like yours:

(defn merge-pdfs [output-combined-pdf-path pdf-files]
  (shell "pdftk",
         (vector pdf-files),
         "cat",
         "output",
         output-combined-pdf-path
         )
  )

But mine doesn't work

this is because shell expects strings as arguments, not vectors of strings :)

you are passing this to shell:

(shell "pdftk" [....] "cat" "output" output-combined-pdf-path)

but it expects:

(shell "pdftk" ... "cat" "output" output-combined-pdf-path)

oh so like str* ?

where it can either be single string or multiple...

what is str*?

idk how it's called in

in JS there is ...str

rest parameter

ah yes, the str function accepts one or more strings, this is called "varargs"

and shell is a varargs function: it accepts one or more arguments

I see 🙂 yes that's what I meant exactly

thanks for teaching me how to write better code

and how to call this

:hugging_face:

🙌

🙌

Hovering on shell in my editor gives me the docs: > [...] The first command line argument is automatically tokenized Does tokenized means adding the single-quotes on path strings?

and if so, is it really only the first argument? because there is "pdftk", "file1", "file2" "cat" "output", then first argument "file1" is tokenized? but about what bout "file2" is that also tokenized?

you can call (process/tokenize "foo bar 'foo bar'") to see what it does

only the first argument to shell is tokenized, e.g.: (shell "ls -la") => (shell "ls" "-la")

but arguments after the first argument are not tokenized

this is just so you can easily copy things between bash and shell . you don't have to use that feature

Oh this is not related to the issue I had with single quotes

yes it is because what you did is concatenate everything to one big string and then feed that as the only string to shell

so then shell tokenizes that again and pulls it apart in separate strings again

Sorry that it's hard to explain this to me, I'm not aware of this terminology...

I do understand sometimes 🙂 other times it falls on deaf ears

ok, if you write (shell "foo bar 'foo bar'") this executes the same as (shell "foo" "bar" "foo bar") because shell pulls apart the first string

and you constructed one big string like (shell (str/join " " files)) so shell first tokenizes (pulls apart) that big string into separate strings

and if one of the file names contain spaces, you get two words instead of just one

but it's better to just use separate strings to begin with

if you already have those as separate values

hope that makes sense

So the shell function received my long string and then pulled it apart on the whitespaces?

yes. if you write:

(shell "rm my file")

but if you already have "rm" and "my file" there is no need to make that into a single string, just pass them both:

(shell "rm" "my file")

oh I thought it was gonna send that verbatim to the shell for execution directly

but it's your library and you designed it certain way

and I'm only the consumer

so I need to read your docs to understand how to use it

🙂

yes

plz read the docs? :)

Thank you for such great explanation!! very much appreciate you ❤️

:-D

Thx for shelling out tutorial!

@UDXEK491P

(spit (fs/file (fs/create-temp-file)) "foo")

ah i missed that function, ty!

and that is great to hear