yassenefremov / cpm

A C/C++ package manager made for my diploma thesis

• 👋 Hi, I’m Yassen Efremov
• 👀 I’m interested in math, computers and space
• 🌱 I’m currently studying at FMI
• 💞️ I’m looking to collaborate with my classmates and friends
• 📫 How to reach me - [email protected]

cpm's Issues

Write fourth chapter

Add basic logger

It should log status and error messages to the console or a file.

Libraries: Logging

Upload catch2 tests to GitHub actions

Create basic package script

The script should be a json file (for now). It should store the package dependencies instead of the local package DB, which should be in the user's home directory anyway.

Create basic CLI

Should support the following commands:

• install
• remove
• list
• update

Should support the following flags:

• --version
• --help

Library: argparse

Write first chapter

Talk about client-registry, dependency management, package metadata, etc. and existing solutions (conan, vcpkg, npm, pip).

Implement basic `info` command

This command should show information about the specified package:

• name
• version
• dependencies
• url
• author

etc.

Implement basic `install` command

Download (and decompress?) the given GitHub repository to <cwd>/lib/<repo-name> (for now).

Libraries: Communication

Implement basic `remove` command

Remove the given package from <cwd>/lib/<repo-name> (for now).

Implement basic `search` command

Write third chapter

Implement basic `list` command

List all of the installed packages (records for which should be stored in the local package DB)

Implement basic `sync` command

The command should parse the current cpm_pack.json file and install/remove the package dependencies listed in there.

Fix `sync` command not working when a lockfile is present

Implement basic `update` command

This command should update the specified packages. (maybe by checking their version and installing the newest version?)

Create basic local package DB

The DB should contain a table that stores the installed package's names (for now).

On cpm install <package-name> -> add <package name> to the DB.
On cpm remove <package-name> -> remove <package name> from the DB.

Libraries: Databases

Check and remove package dependencies

Recursively install package dependencies

When installing a package, it's cpm_pack.json should be parsed and all of the dependencies listed in there should be installed as well. After that all of the dependencies dependencies should also be installed and so on...

Add lockfile support

A lockfile should be generated when installing new packages and it should be used to install a package's dependencies.

Show package download and decompression status in console

Should show {extracted}/{all} and {downloaded}/{all}

Add error handling for sqlite and create custom exceptions

Because sqlite's error messages are dynamically allocated, throwing an exception with one makes it impossible to free the char * containing the message afterwords. To fix this a custom exception could be made that frees the error message in its destructor.

Implement basic `create` command

This command should create a new package in the current working directory, e.g. it should create a package.json file with the package name and version.

Show command execution time

Show how long it took for the current command to execute (in ms/s).

Write conclusion

Install packages using only their name

Instead of using URLs to install packages we could look in a specific location (for example in a GitHub organization) and use just the package name.

Remove dead code and fix try/catch block

Add support for different versions of the same package

Create example CPM repositories

Create a couple of example CPM package repositories to make testing easier.

Use CPM to manage its own dependencies

For now split-string is really the only dependency that can be managed by CPM.

Write second chapter

Specify locations that should be searched for packages

There should be a global configuration file that lists all locations that should be searched when installing packages.

Finish CMake installation rules

Install packages asynchronously

Use separate threads to install packages.

Improve dependency installation algorithm

pseudocode:

install() {
    for d in package.deps:
        if not d.installed:
            install(d)
    zip = download(package)
    extract(zip, "{cwd}/lib")

    for d in package.deps:
        symlink("lib/{d}", "d")
}

Save logs to file

The program should log more detailed information to a log file during it's execution and when an error occurs.

Optimize `cpm`'s dependencies and CMakeLists.txt

Add checks for curl, sqlite, ... in the CMake script (using find_package)

Add option to list all packages recursively

The list command should have an option like -a/--all that lists all of the currently installed packages recursively.

Refactor local package DB and commands

There should be a class providing a simple interface to interact with the local package DB (add, remove and list functions).

Show basic install progress bar

ASCII progress bars should be shown when installing and removing packages.

Allow existence of different versions of the same package

Add option for global package installation

Packages could be installed in two ways:

• locally to the project (no additional arguments needed, installed in cpm_pack.json)
• globally to the user (-g/--global, installed in packages.db3) (also remove/list -g)
• globally to the system (-s/--system, installed in packages.db3)

Add support for package versioning

Each package should have a version and all commands should be aware of package versions.

Add bibliography

For used resources and references

Fix local package DB

• primary keys should be formed from both the package name version
• rename same files/tables?

Tell the user how to use installed packages

After the install command has finished executing, a message should be displayed that tells the user what to add to their CMakeLists.txt in order to use the installed package.

Add version tags to example repos

Use git tags to manage package versions

Prevent circular dependencies

Detect circular dependencies, warn the user about them and tell them to refactor their code.

Write introduction

Should be about a page long.