proji-rocks/proji

A powerful cross-platform project templating tool.

A powerful cross-platform CLI project templating tool.

Key Features

• Creates project directories of any size in seconds
• Project templates are based on individual config files
• Structures of GitHub/GitLab repos can be imported as templates
• Structures of directories can be imported as templates
• Infinitely extendable through integration of custom shell scripts
• Supports custom template files
• Shareable project configs
• Projects are not bound to any language or framework
• Boosts your productivity and simplifies your workflow
• Works on Windows, macOS and Linux

Project Status

Proji is currently in an advanced stage of heavy refactoring. The current default branch is not stable and should not be used in production. The new version will be released soon.

proji's Issues

Switch from python to golang

Switching to golang out of personal reasons. Learning go atm and trying to become better at it. This will be my first go project.

Rename project table to class table

Table name project is not suiting for its purpose. New name might be class. Table project should keep track of projects.

Proji create: __PROJECT_NAME__ created two folders

I added a new class (golang maybe it's still in the database) and assigned it a folder cmd/__PROJECT_NAME__.
After running the command proji create go testProj proji created a correctly the subfolder cmd/testProj but additionally and falsely the subfolder cmd/__PROJECT_NAME__.

Use viper and cobra for better cli functionality

Use viper to load configuration files and cobra for cli arguments.

Related to #1, #5, #6, #10.

Write all tests

Write tests for all remaining functions.

Add indexes to sqlite deploy script

Add indexes to the sqlite deploy script. Should improve overall performance especially with growing database size.

Move my templates to an example folder

Move my personal templates to a example folder in the proji config folder. When proji gets installed there should be an empty template folder.

Maybe add a command flag like proji class add --from-example cpp which would copy my cpp class to the templates folder.

Add a class remove command

Create the opposite of #6. Enable user to remove classes from the database.

Should be like:

proji class remove myClassName

Improve project management

Add functions that allow the user to load, remove update and change the status of projects. Currently only the project creation is supported.

Build script

Add a build script which automatically builds the project for a set of platforms and architectures.

Keep track of projects

Created projects could be added to the database in the table project. Should keep track of name, class, location and creation date.

A command like proji status could check the status of all active projects.

Sqlite: Create DB if not exists

If the function sqlite.New doesn't find the given db file, create it and create the the proji tables in it.

'Class import' imports non toml files

Class import command imports non toml files, creates a empty class and returns success.

Check if given file is toml and check if toml file meets proji config criteria. Respond with an error if not.

Add 'cd' command

Add a cd like command which lets the user quickly change into a project directory.

Add flag to 'class add' command for creating an example addClass.toml file

Add a flag like --load-template which will create a new file in the users current directory. The file will contain a basic structure of data for adding a new class to proji (example config)

Add 'ls' childcommand to 'class' command

Add a ls functionality to class command similar to docker container ls. List all available classes.

Export/import class from database

Create an option to export and import the setup of specified class from the sqlite database.
Export it to json or something along those lines.

Enables useres to share setups/configs.

Windows and Mac support

Functions that use system paths would currently not work under windows. Think about implementing windows support.

Question is, if it's worth the effort.

Clean up storage interface

Storage interface feels bloated and some functions seem pretty redundant. Simplify and clean up the code.

Create class from stdout of command like ls

Pipe the output of a listing program like ls in this program (maybe with a flag) and create a new class from it in the database.

e.g.: ls -a | proji class add --from-stdout <name>

Add show subcommand to class command

The show subcommand should show all information about a given class. Information like name, labels, folders..

Many functions in cmd/proji are erroneously exported

Functions in the files for the different sub commands are mostly exported which they shouldn't be. These functions are not reused and only serve a purpose for the sub command they're assigned to.

Fix travisci tests

Travis fails to build the application because it can't find the necessary database containing languages, folder etc. Currently the database is only available on my local machine.

Have to edit travis.yml and tell it to deploy the database.

Completion for imports

proji class import doesn't auto-complete the file system when tab-completion is enabled. Paths and file names have to be entered manually.

Improve errors

In some functions before returning to the caller the last action is to execute another function, receive a potential error, check if an error occurred and return the error if so. If no error occurred just return nil. Simplified version with the same result would be to return the result of the last function directly without evaluating it.

Looks like this:

err := someFunc()
if err != nil {
    return err
}
return nil

Should look like this:

return someFunc()

Scripts don't work interactively

When a script like init_git.sh is being executed the output and input of the script isn't piped to proji thus the script just executes and the user is not able to interact with the running script.

Fix sql unique index constraints

The unique constraints for the tables class_folder and class_file are not set up properly.
The unique index should be between project_class_id and target_path, currently it's the target_path and the template_name which results in the possibility to create multiple files or folders with the same target_path.

Now, changing the index accordingly would result in a problematic situation for globals. If the index is between project_class_id and target_path it is possible to create duplicate target paths because there might be a target path testPath which would be assigned to a project_class_id` but there might be the same target path assigned to a global. This doesn't hurt the unique constraint because the global and class don't share the same id.

Possible solution is to export the globals into separate tables.

Integrate variables into sqlite

Problem:
It's currently not supported to dynamically create folders or files based on for example the name of the project that's currently being created. In python it's not untypical to name the folder containing most of the source code after the project itself. So the project test-py should contain a folder named test-py. This behaviour is currently not supported.

Possible solution:
Add key words to the cell values in the sqlite database. Currently for example the target_path column in the folder table would contain a cell with the value src/. And to make this value dynamic add recognizable key words like __PROJECT_NAME__. So this would result in a cell value of src/__PROJECT_NAME__. And the key word could be replaced with the actual project name during runtime. Regex for example could search for occurrences of these key words and replace them accordingly.

ReadMe

Write a good and modern readme.

Add setup script

Add a script that installs the application. It has to create the config folder, deploy the database, and put the app in a folder like /usr/bin.

Integrate go routines

Currently proji runs in a single go routine. It would be useful in certain areas to improve performance by using multiple go routines. For example, when creating files and directories or importing multiple configs.

Add 'add' command

Creating of projects is now possible. What's missing is the individualization. Add an 'add' command which makes it possible for the user to add classes to the database.

Export class doesn't show file name

When exporting a class the export process itself is successful but the info message doesn't print the name of the exported file.

Actual: Class python was successfully exported to file .
Expected: Class python was successfully exported to file proji-python.toml.

What should happen when no arguments are given?

What should happen when proji is called by itself. Error, help or an interactive creation mode?

Add proji command 'global'

global command should have a similar functionality like the class command.
With global the user should be enabled to add new globals - files, folders and scripts that do not belong to any specific class and are always included or executed.

Example:

proji global add --folder new-folder/
proji global add --file new-main.prj
proji global add --script new-script.sh

Add 'clean' command

Add a clean command that iterates over the projects list and checks for dead project paths, missing statuses and such.

Prettify console output

Colorize errors red, colorize project names, success messages.. etc
Package: aurora

Maybe add tables of some form likely for commands that display data like class show/ls.
Package: tabby

Add a config

Add a general config file.

Possible options so far:

• config directory
• default editor

Add documentation

Add extensive documentation for the whole project.

Change cli argument order

Change cli argument order from create_project <project_name> <language> to create_project <language> <project_name>.

Less annyoing when creating new projects with the same language.

Add bash/zsh completion

When cobra is fully integrated add tab completion for the arguments.

Add 'class' 'import/export' subcommands

Import a class config from a config file(probably toml). And export existing classes to a config file. Enables users to share class configs.

Replaces add --from-file flag in #6.

Refactor everything

Use tools like staticcheck and safesql to check for possible improvements. Look for duplicate code manually and with help from tools like dupl.

Add 'add' command

Add 'command' to add an existing project to the storage.

Database: Label unique index

Currently the unique index for the table class_label is between the columns project_class_id and label. This allows different classes to have equal labels which is problematic since proji creates new projects based on a given label. If a label is shared between to classes, proji won't now which class to choose.

The unique index should only be on the label column granting that every label is unique and labels can't be shared between classes.

Change name 'class' to 'template'

Change the name class to template. Template describes better what the purpose of this function group is.

Old: proji class add myClass
New: proji template add myTemplate

Write go unittests

Transition from python to go is mostly done. Only thing missing are the unittests and circleci integration.

Track more data

Think about tracking more use stats like the calls of a specific class, project creation date..
With this data you could draw interesting usage graphs or calculate how much time the user has saved by using proji.

Make sql queries more stable

Make the sql queries more stable by regulating the user input. For example make all labels and class names lowercase before inserting or querying.

Allow simultaneous creation of multiple projects

The cli argument for the project_name may become a list instead of a string which would allow iterating over and creating multiple project names in one command. Otherwise the whole command needs to be executed multiple times with different project names.

Example old style:
create_project cpp proj1
create_project cpp proj2
create_project cpp proj3

Example new style:
create_project cpp proj1 proj2 proj3