is copy-files a kosher way to copy one directory to another in a task? https://github.com/boot-clj/boot/blob/2.5.2/boot/pod/src/boot/file.clj#L172

something like;

(deftask foo []
  (fn [next-task]
    (fn [file-set]
      (boot-file/copy-files "public/" (str "public/" (env :ver 0) "/"))
      (next-task file-set))))

sure, the "public" directory isn't in the fileset right?

^^ @kenbier

@micha “public/“ is in resources/public. and my :resource-path is set to “resources”.

so i suppose it is in the fileset ?

ah so you don't want to do that

you can use the sift task for that

but i want to copy it, not move it

i plan to add a tag to that directory in each release, and sync it to s3

but i also want to leave the public/ intact

and from what i understand :sift does not have a copy

i did find a boot-copy task but it seems its not maintained and is using deprecated api 😕

got a better suggestion on how to copy everything from public -> public/some-number/ ?

ah, the sift task should have a copy

that's a bummer

there is the boot.core/cp function

but it has a bug currently, see https://github.com/boot-clj/boot/issues/502

hm is the bug only in 2.6? we are on 2.5.2 atm

ah 2.5.5 is ok, so 2.5.2 is also presumably

we really want a copy option to the sift task

the easiest thing to do in your case i think is to make a temp dir, copy the files into there

and add that to the fileset

you will then have duplicate copies of the file in different paths

if you want to remove the original you can do that by removing them from the fileset

you can use boot.core/rm to remove them

so like this, in sketch

(deftask foo []
  (let [tmp (tmp-dir!)]
    (with-pre-wrap fs
      (let [ins (->> fs
                     (output-files)
                     (by-re #{#"^public/"}))]
        (empty-dir! tmp)
        (doseq [in ins]
          (io/copy (tmp-file in) (io/file tmp "public" tag)))
        (-> fs (add-resource tmp) (rm ins) commit!)))))

you can improve on this by caching the previous fileset object and diffing it

then you don't need to copy all the files each iteration

only the ones that chanegd

but the main idea is you make a temp directory where you can copy your files to

with different paths

then you add that to the fileset and remove the original files from the fileset

and finally you commit! to sync with the underlying filesystem and pass the result to the next task

oh sorry, i'm dumb, you said you didn't want to move them

yeah

so disregard the stuff about removing the originals

yeah the same but no rm right?

right

sweet, thanks alot @micha !! helpful as always 🍪

oh sorry

one sec there is a bug

k

oh another question, what if i only need these copied file to be present for another boot task called bar? instead of committing them, could i run barafter altering the filesystem?

so it runs in the context of this modified filesystem, but its not one we pass to the next task? or is that an anitpattern?

i can live without it, just curious

(deftask foo []
  (let [tmp (tmp-dir!)]
    (with-pre-wrap fs
      (let [ins (->> fs
                     (input-files)
                     (by-re #{#"^public/"}))]
        (empty-dir! tmp)
        (doseq [in ins]
          (let [[path file] ((juxt tmp-path tmp-file) in)
                relpath (.replaceAll path "^public/" "")]
            (io/copy file (io/file tmp "public" tag relpath))))
        (-> fs (add-resource tmp) commit!)))))

in general it's good to design things so that tasks are as decoupled as possible

makes thinsg more hackable

the fileset pattern is what makes that possible in most cases

i see, that makes sense. its like ring where we wrap the middleware?

right, so you can separate concerns in the different layers

ah cool

this should be fine

what does the relpath part do in the snippet above?

the bug in the first one was not handling the relative path underneath public

because you need to transform "public/foo.clj" --> "public/1.0/foo.clj" right?

right

yeah the relpath part is handling the "foo.clj" part of the path

but there is one more bug 🙂

you need to use io/make-parents to ensure that the subdirectories exist

before trying to write to the copy output file

so like (io/copy file (doto (io/file tmp "public" tag relpath) io/make-parents)))

i always forget that

ah yes, makes sense

if you'd like to make a github issue for the sift --copy option, we can make it happen for 2.7.0

sure, ill do that

thanks! 💥

np

@richiardiandrea made https://github.com/micha/json-table/tree/key-wildcard if you're interested - adds . and ^k operators to jt

@alandipert: I am ! I will check it out

Is there a way to get the latest version of a dependency (including snapshots)? "LATEST" seems to ignore snapshots.

there is a trick: "(0,)" @domkm

Thanks

@alandipert you still need to have a % at the end for "gets" right?

@richiardiandrea yep

kk I should patch that 😄

there was a problem with it

i wrote it up in the branch

ok digging

https://github.com/micha/json-table/commit/167c5ed6f181e1cfa2f69a2f7fe4926bc1f5c2a1

ooooh there it is ... yeah makes sense...

so up to there user to discern what he/she wants and less logic in the code, it makes sense, less ambiguity

yeah we use it for scripts that need to be robust to weird json

so it's good to know exactly what will be output

the key wildcard looks great for exploring