I have a (relatively) large Module where all the code is organized in my homegrown file and directory structure. I now want to transfer this code into the directory structure of a Pkg package (i.e project/manifest.toml, src/test folders etc). Ideally I would like to maintain the git history (unless this is a particularly bad idea).
My plan was something like this:
-Generate and empty project with the same name as the Module (Pkg.generate)
-Copy all the original files to this folder (including .git)
-Move all the files to their appropriate places (i.e. src and test)
-Change any path specifications in the code if necessary
-activate the folder environment and add any packages the module uses.
-commit changes, push.
Then I should be able to add and use the package in other applications by Pkg.add from the git repo.
Is this a good plan or am I missing something? Or is there a better way?
It might be easier to do it the other way around. The only really useful things that will be generated are the Project.toml file and the folders src, test etc. (and perhaps the file test/runtests.jl).
So after generating the files in some new directory, I would copy them into the existing project (keeping around the original Project.toml and Manifest.toml temporarily if something goes wrong, e.g. just rename them).
Then you can rename/move/edit all the files as needed and sort them into the right places, add the dependencies to the new (now empty, but containing the UUID and package name) Project.toml, and test if everything is working. At the end, you can make one big commit “reshaping” your existing repo into a package – that way you can keep all the git history without the hassle of duplicating the .git folder.
Strong agreement on doing Pkg.generate in a temporary location, copying Project.toml into the existing repository, and moving the files as necessary to get the right directory structure.
Since you already have a git repo, you can also restore files etc. if something goes wrong (assuming it’s also on some remote server). I often find myself taking version control for granted, but every now and then I feel truly amazed by how convenient some things have gotten nowadays.
