https://github.com/pedrohenriques/projectmanager
An easily customizable python program that makes it easy to create projects and files with predefined content.
https://github.com/pedrohenriques/projectmanager
file-manager project-manager scaffold-files
Last synced: 12 months ago
JSON representation
An easily customizable python program that makes it easy to create projects and files with predefined content.
- Host: GitHub
- URL: https://github.com/pedrohenriques/projectmanager
- Owner: PedroHenriques
- License: mit
- Created: 2016-09-23T15:39:32.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2017-01-23T16:53:57.000Z (over 9 years ago)
- Last Synced: 2025-04-17T12:31:40.649Z (about 1 year ago)
- Topics: file-manager, project-manager, scaffold-files
- Language: Python
- Homepage:
- Size: 23.4 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Project Manager
An easily customizable python program that makes it easy to create projects and files with predefined content.
## Instructions
### Setup
#### => Running the program and Batch file:
In order to run the program the file `main.py` must be called from the command line or terminal with the required parameters.
To facilitate running the program, by being able to call it from any path, the repository comes with a **batch file**.
This batch file will not only allow the program to be called from any path, as well as allow relative paths to be given as arguments.
Before being able to use the batch file from any path, it must be placed in a directory that is part of the `PATH` environmental variable (in windows).
Secondly, in the batch file the line `set "file_path=path\to\main.py"` must be adjusted by changing `path\to\main.py` with the path to the `main.py` file.
Finally, the name given to the batch file will be the name used in the command line to run the program.
#### => Configuring/Customizing the Program
**JSON files:**
Each action has a JSON file, named after the action, that contains all the data needed for that action's execution.
The syntax of these files is as follows:
- The data can be organized in as many levels deep as needed
- The data that will be used in the action proper will, in general, treat keys as either file or directory names and their values as either the file or the directory's content.
- Files have `strings` as values. These strings contain the file's content. An empty file should have an empty string as it's value.
- Directories have `objects` as values. These objects contain the files and directories that should go inside this directory. An empty directory should have an empty object as it's value.
NOTE: The **help** action is an exception to these rules. For further information on the help action consult the related topic below.
Example:
```
{
"python" : {
".gitignore" : "",
"main.py" : "print(\"Hello World.\")",
"classes" : {
"__init__.py" : "__all__ = [\"Application\"]",
"Application.py" : "class Application :\n\t\"\"\"This is the application's main class.\"\"\"\n\n\tdef __init__(self) :\n\t\tpass"
},
"data" : {}
}
}
```
In this example, if the program is told to create a new python project (exact syntax further down), inside the project's directory the result would be:
- An empty file named `.gitignore`
- A file named `main.py` with content `print("Hello World.")`
- A directory named `classes`, inside of which is:
- A file named `__init__.py` with content `__all__ = ["Application"]`
- A file named `Application.py` with content
```
class Application :
"""This is the application's main class."""
def __init__(self) :
pass
```
- An empty directory named `data`
**Special Keywords:**
The content of files, created by both the file and the project actions, can have special keywords that will be replaced by dynamic or static data.
All keywords are in the format `|!keyword{multiplier}[case]!|`.
- `keyword`: One of the supported keywords. See below for a list of global keywords, as well as, how to add your own.
- `multiplier` (Optional): An integer (whole number) indicating how many times that keyword replacement should be inserted.
- `case` (Optional): A tag indicating a specific case status for the keyword replacement. The supported tags are:
- `uc`: insert the keyword replacement in UPPERCASE.
- `lc`: insert the keyword replacement in lowercase.
- `t`: insert the keyword replacement Capitalized.
The **global keywords** are:
Keyword | Replace Value | Supported Actions
--- | --- | ---
copyright | copyright text
see below for details on how to customize the text | project
file
project_name | the new project's name | project
file (1)
file_name | the new file's name | project
file
file_type | the new file's type | project
file
project_type | the new project's type | project
no_www_domain | the new project's name, striped of any starting "www." | project
(1) When creating a new file, the code will search the file's path for the first directory with a `.git` folder inside it. That directory will be treated as the file's project_name.
Adding **custom keywords**:
All custom keywords and their replacement strings are defined in the `keywords.json` file.
Any keywords added to this file will become usable in all the actions.
It is valid to use other keywords in the replacement string.
This is also where the copyright text is defined and can be customized.
NOTE: the code expects the keyword to have a string as a value in `keywords.json` and will replace it with an empty string if that is not the case.
### Using the Project Manager
The syntax expected by the program depends on the desired action to be executed.
The available actions are:
- project
- file
- help
#### => Project Action:
The **project** action will create a new project directory, populated with any files, plus their content, and directories specified in the `project.json` file.
The command line syntax for this action is `project location name type` where:
- `location`: path to the directory where the project's folder should be created.
If running the program through the batch file a path relative to the working directory can be given, and a `.` can be used to indicate the working directory.
If running the program by calling main.py directly, then an absolute path must be given.
- `name`: the name for the project's folder.
- `type`: the type of project to be created.
The `type` of project to be created should match the data available in `project.json` and a `:` should be used to navigate the JSON's tree levels.
**Example:**
For a `project.json` file with the following structure:
```
{
"website" : {
"php" : {
...
},
"cs" : {
...
}
},
"python" : {
...
}
}
```
And assuming the working directory in the command line is `C:\work`:
- to create a new `php` project named `personal_site` the following command would be used `project . personal_site website:php`.
- to create a new `python` project named `calculator` the following command would be used `project /portfolio calculator python`.
#### => File Action:
The **file** action will create a new file, with the content relevant to its extension, as specified in the `file.json` file.
The command line syntax for this action is `file location name type [-flags]` where:
- `location`: path to the directory where the file should be created.
If running the program through the batch file a path relative to the working directory can be given, and a `.` can be used to indicate the working directory.
If running the program by calling main.py directly, then an absolute path must be given.
- `name`: the name for the file (without the extension).
- `type`: the type of file to be created.
- `flags`: optional argument with the desired flags. The supported flags are:
`f`: forces the creation of the file by creating any directories in the given path that don't exist.
`o` : if a file with the same path already exists, it will be overwritten.
The `type` of file to be created should match the data available in `file.json` and a `:` should be used to navigate the JSON's tree levels.
The code expects `file.json` to have a key `extension` with a string value containing the file's extension and a key `content` with a string value containing the file's content.
**Example:**
For a `file.json` file with the following structure:
```
{
"class" : {
"php" : {
"extension" : "php",
"content" : "..."
},
"python" : {
"extension" : "py",
"content" : "..."
}
},
"js" : {
"extension" : "js",
"content" : "..."
}
}
```
And assuming the working directory in the command line is `C:\work`:
- to create a new `php class` file named `Player` the following command would be used `file /game Player class:php`.
- to create a new `js` file named `main` the following command would be used `file /site/assets main js`.
#### => Help Action:
The **help** action will display help information about the program, as specified in the `help.json` file.
The command line syntax for this action is `help [topic]`.
If no topic is given, the list of topics will be displayed, otherwise detailed information about the given topic will be displayed.