README
¶
Proji is a simple and fast project creator and manager.
Table Of Contents
About
I always endeavored to structure my projects as consistently as possible. I do not want to switch from one project directory to another and have to get used to it each time before I can even start working. This means that I always would have to create the same folders and files for each project directory of a specific topic. However, this costs a lot of time and keystrokes. The solution would be to automate the creation of topic-specific project directories and that's exactly what proji does.
My goals with proji are to save time when creating new projects and to have consistently structured project directories.
Getting Started
Proji is currently only supported under linux. You can either download a pre-compiled binary from the latest release or install it from source.
Might work under Mac but it's not tested yet.
Dependencies
- go - Main language
- sqlite3 - Database
- mattn/go-sqlite3 - Go Sqlite3 Driver
- spf13/cobra - CLI commands
- spf13/viper - Manage config file
- BurntSushi/toml - Go toml parser
- toml-lang/toml - Config Language
- jedib0t/go-pretty - CLI Styling
- stretchr/testify - Test Framework
Installation
Binary Distributions
- Download the latest release for your system
- Extract the tar with:
$ tar -xf proji-XXXX-XXX.tar.gz - Run the installer:
$ ./install.sh
Install From Source
$ go get -u github.com/nikoksr/proji$ go get -v -t -d ./...$ go install ./cmd/proji/orgo build -o proji ./cmd/proji$ ./install.sh
Validate the success of your installation by executing $ proji. The help text for proji should be printed to the cli.
Running The Tests
$ go vet ./...$ go test -v ./...
Tab Completion
Proji does support tab completion but at the moment you have to set it up yourself. The following instructions were inspired by kubernetes completion.
Bash
For this to work you first need to install and enable bash_completion.
You now need to ensure that the proji completion script gets sourced in all your shell sessions.
# Create the completion file
./proji completion bash > ~/.config/proji/completion.bash.inc
# Make your bash_profile source it
printf "
# Proji shell completion
source '$HOME/.config/proji/completion.bash.inc'
" >> $HOME/.bash_profile
# Source it once for immediate completion
source $HOME/.bash_profile
Zsh
This command will create a zsh completion file in your current users default zsh completion folder:
./proji completion zsh > "${fpath[1]}/_proji"
Basic Usage
Suppose I create python projects on a regular basis and want to have the same directory structure for each of these projects. I would therefore have to execute every command necessary to create the appropriate directories and files and would then have to run tools like git and virtualenv to fully get my usual development environment up and running.
That would not be too bad if you only create a new project every few weeks or months. However, if you want to create new projects more regularly, be it to test something quickly, learn something new, or quickly create an environment to reproduce and potentially solve a problem found on stackoverflow, then this process quickly becomes very tiring.
Setting up a Class
To solve this problem with proji, we first have to create a so-called class. A class in proji represents the structure and behavior for projects of a particular topic (python in this example). It serves as a template through which proji will create new projects for you in the future.
In our case, we want to have the same basic structure for our python projects in the future. So we'll create a class for python. This class will determine which directories and files we always want to get created by proji and which scripts proji should execute after project generation, for example a script for git which automatically initializes the project, creates several branches and executes a first commit.
Note that folders and files can either be created new and empty or be copied from a so-called template. In the config folder you can find a template folder (~/.config/proji/templates/) in which you can store folders and files that you want to use as templates. In our example we could put a template python file into this folder. The file could contain a very basic python script something like a 'hello world' program. We can tell proji to always copy this file into our newly created python projects. The same goes for folders. The goal of the templates is to save you some more time.
In addition, we can assign scripts to a proji class which will be executed in a desired order after the project directory has been created. Scripts must be saved under ~/.config/proji/scripts/ and can then be used by name in the class.
Structure of a Class
- Name: A name that describes the type/topic of the class (e.g.
python) - Label: A label that serves as an abbreviation for easily calling the class (e.g.
py) - Folders: A list of folders to be created
- Files: A list of files to be created
- Scripts: A list of scripts to run after the project directory has been created
Create a Class
There are two ways to create a new class:
1. Config file (recommended)
Proji offers the possibility to export and import classes through config files. The easiest way would be to export the proji sample config and then adapt it to the needs of the class you want to create. To do so execute the command $ proji class export --example ..
Proji creates the file proji-class-example.toml in the current working directory. If you open this file in a text editor, you will find a richly annotated configuration of an example class. This config should then be adapted according to your needs.
Once the config has been edited and saved, it can be imported using the $ proji class import proji-class-example.toml (or whatever you called the file) command. Proji then creates a new class based on the imported config.
Note: You can import multiple configs at once.
2. Class add command
The second option is to use the $ proji class add CLASS-NAME [CLASS-NAME...] command to create one or more classes in an interactive CLI. Proji will query the necessary data for the new class from you and then create the new class based on that data.
The advantage of the config file is that incorrect information can easily be corrected. For example, if you entered a script that does not exist or whose name was simply misspelled, you can easily change the name in the configuration file. This is not possible in the CLI menu. If the entry is incorrect, the creation process must be restarted.
After the class has been created or imported, we can use the command $ proji class ls to display a list of our available classes. The command $ proji class show LABEL [LABEL...] allows us to display a detailed view of one or more classes.
Creating our first projects
Now that we have created our python class in proji, we can use it to easily create new projects. A class is created once and is then reused by proji over and over again, and although the process of creating a class might initially seem a bit complex, you will very soon start saving a lot of time and keystrokes and will improve the structure of your projects.
Assuming our class has been assigned the label py, we can create one or more projects with the command $ proji create py my-py-project-1 my-py-project-2 my-py-project-3.
And voilà, proji has created three new project directories where you can start your work immediately. The project directories are all built identically, have the same subdirectories and files, and all ran the same scripts.
Take a look at the python class config and the git and virtualenv scripts that were used in this example.
Advanced Usage
Help for all commands is also available with $ proji help.
Class
-
Add a class:
$ proji class add NAME -
Remove a class:
$ proji class rm LABEL [LABEL...] -
Import a class:
$ proji class import FILE [FILE...] -
Export a class:
$ proji class export LABEL [LABEL...] -
List all classes:
$ proji class ls -
Show class details:
$ proji class show LABEL [LABEL...]
Project
-
Create a project:
$ proji create LABEL NAME [NAME...] -
Add a project:
$ proji add LABEL PATH STATUS -
Remove a project:
$ proji rm ID [ID...] -
Set new project path:
$ proji set path PATH PROJECT-ID -
Set new project status:
$ proji set status STATUS PROJECT-ID -
List all projects:
$ proji ls -
Clean up project database:
$ proji clean
Status
-
Add a status:
$ proji status add STATUS [STATUS...] -
Remove a status:
$ proji status rm ID [ID...] -
List all statuses:
$ proji status ls
License
Proji is released under the MIT license. See LICENSE
Directories