Metadata-Version: 1.1
Name: jingerly
Version: 0.0.2
Summary: Project templating using Jinja2.
Home-page: https://github.com/WilliamMayor/jingerly
Author: William Mayor
Author-email: jinjerly@williammayor.co.uk
License: MIT
Description: # jingerly
        [![Build Status](https://travis-ci.org/WilliamMayor/jingerly.svg?branch=master)](https://travis-ci.org/WilliamMayor/jingerly)
        [![Latest Docs](https://readthedocs.org/projects/jingerly/badge/?version=latest)](http://jingerly.readthedocs.org/en/latest/)
        Project templating using Jinja2.
        
        Easily create a blank project skeleton from a project template using the following features:
        
        - Jinja2 templated files
        - Templated file/folder names
        - Download files from the Internet
        - Copy local files into the project
        - Run custom scripts before and after creation
        
        ## Usage
        
        Create a new project directory from a project template:
        
            $ jingerly ~/templates/web ~/projects/next-big-thing
        
        This copies over all of the files in `~/templates/web` and puts them in `~/projects/next-big-thing`.
        
        ### With Template Variables
        
        Let's say your project template has a template `README.md` file that looks like this (using the Jinja2 templating language):
        
            # {{ project_name }}
            {{ short_desc }}
        
        You can fill in those variables like this:
        
            $ jingerly ~/templates/web ~/projects/next-big-thing \
                --project_name=nbt \
                --short_desc="It's going to be awesome"
        
        You'll see a file in `~/projects/next-big-thing/README.md` that looks like this:
        
            # nbt
            It's going to be awesome
        
        jingerly automatically defines the variables `IN` and `OUT` for you to use in your templates. `IN` is the template directory you provide (`~/templates/web`) and `OUT` is the output directory (`~/projects/next-big-thing`).
        
        ### With Variable File/Folder Names
        
        The file and folder names are run through Jinaj2 too. So you can have a directory template tree that looks like this:
        
            web/
                {{project_name}}/
                    {{project_name}}.py
                README.md
        
        Then you can run the previous `jingerly` command and see this:
        
            next-big-thing/
                nbt/
                    nbt.py
                README.md
        
        ### With Interactivity
        
        If you don't want to list your variable names and values on the command line you can fill them in interactively:
        
            $ jingerly ~/templates/web ~/projects/next-big-thing --interactive
            Value for project_name (leave blank to ignore): nbt
            Value for short_desc (leave blank to ignore): It's going to be awesome
        
        ### With Pre-Defined Variable Values
        
        If you create a file called `jingerly.env` in your project template then jingerly will automatically pick up the values you define inside it. It's read in as a Python file so your variable definitions must be in the Pythyon syntax.
        
            web/
                {{project_name}}/
                    {{project_name}}.py
                README.md
                jingerly.env
        
        `jingerly.env`:
        
            project_name = 'nbt'
            short_desc = "It's going to be awesome"
        
        ### With Files Downloaded from the Internet
        
        You might want to download a file when you create a new project, so jingerly adds a download filter into Jinja2. Let's say you want the latest version of jQuery so you create a template file called `jquery.js` in your project template:
        
            web/
                {{project_name}}/
                    {{project_name}}.py
                    static/
                        jquery.js
                README.md
                jingerly.env
        
        `jquery.js`:
        
            {{ "http://code.jquery.com/jquery-latest.min.js" | download }}
        
        ### With Files Copied Locally
        
        You might want to copy a file in from somewhere else.
        
            gitignore
            web/
                .gitignore
                {{project_name}}/
                    {{project_name}}.py
                    static/
                        jquery.js
                README.md
                jingerly.env
        
        `.gitignore`:
        
            {{ OUT + "/../gitignore" | copy }}
        
        ### With Custom Scripts
        
        jingerly also lets you define some scripts to be run when you create a new project. Create a file called `jingerly.pre` or `jingerly.post` in your project template and make it executable.
        
            gitignore
            web/
                .gitignore
                {{project_name}}/
                    {{project_name}}.py
                    static/
                        jquery.js
                README.md
                jingerly.env
                jingerly.post
        
        `jingerly.post`:
        
            #! /bin/bash
        
            virtualenv {{ OUT }}/venv
            . {{ OUT }}/venv/bin/activate
            pip install --upgrade pip
            pip install flask
            pip freeze > {{ OUT }}/requirements.txt
        
        This will result in:
        
            next-big-thing/
                .gitignore
                nbt/
                    nbt.py
                    static/
                        jquery.js
                README.md
                venv/
                requirements.txt
        
        The scripts are run through Jinja2 before they're executed. `jingerly.pre` scripts will run after the template directory has been copied over into the output directory but before any templating has occurred. `jingerly.post` scripts will be run after Jinja2 has finished rendering the new project.
        
        ## Installation
        
        The easiest way to install everything is to use pip:
        
            $ pip install jingerly
        
        This installs the `jingerly` command line script as well as the Python module (should you want it).
        
        If you don't want to install everything globally then you can use a virtualenv, I like to keep mine in `/usr/local`:
        
            $ cd /usr/local
            $ virtualenv jingerly
            $ . jingerly/bin/activate
            $ pip install jingerly
            $ ln -s ../jingerly/bin/jingerly bin/jingerly
        
        Or, if you wanted to grab the source code:
        
            $ git clone https://github.com/WilliamMayor/jingerly.git
            $ cd jingerly
            $ virtualenv venv
            $ . venv/bin/activate
            $ pip install -r requirements.txt
        
        From here you can run the tests using nose:
        
            $ nosetests
        
        ## Examples
        
        There's an example in the examples directory that demonstrates the features mentioned in this README.
        
Keywords: project management template
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Topic :: Software Development :: Code Generators
