Metadata-Version: 2.1
Name: tplate
Version: 1.0.3
Summary: A project templating tool that based on Jina2
Home-page: https://github.com/wrmay/tplate
Author: Randy May
License: MIT
Description: # Overview
        
        The purpose of tplate is to allow the creation of template based projects.  Jinja2 is used as the templating 
        language.  The tplate tool takes two parameters.  The first parameter is a template directory and the second 
        is the output directory.  All of the files in the template directory are copied to the output directory.  Files 
        ending in ".tplate" are treated as Jinja2 templates and rendered into the output directory. For ".tplate" files, 
        the file name in the output directory will be the template file name minus the ".tplate" suffix.  For example, 
        README.md.tplate would be copied to README.md in the output directory.
        
        There are a couple of exceptions to this.  If a .git folder exists it will not be copied. Neither will any file 
        named "tplate.json", "tplate.yaml" or "tplate_finalize.py".
        
        The template directory must contain a file named tplate.json or tplate.yaml, which contains all of the variables
        that are referenced in the template. The  purpose of this file is to document the variables that are in the
        templates and to provide default values. This file must be copied into the output directory and modified as desired.
        
        The output directory must exist and contain a tplate.json file (or tplate.yaml).  In order to avoid accidentally
        overwriting existing files, tplate will not do anything if there are other files in the output directory.  This can 
        be overridden by passing the --update flag
        
        There are some cases when it is desirable for the output directory structure to be determined by a variable.  Most 
        notably, java package names.  Currently the way to deal with this is with a post processing script.  The script 
        must be placed in the template directory, it must be named "tplate_finalize.py" and it must contain a function named 
        "run" which takes a single argument.  The  argument will be a context which was loaded from the "tplate.json" or 
        "tplate.yaml" file. To access a variable called "java_package" that was provided in "template.json" , the run method 
        would use `context['java_package']`.  Additionally,  `context['output_dir']` will be set to the path of the output 
        directory and `context['template_dir']` will contain the path to the template directory.
        
        The code sample below is the complete contents of a "tplate_finalize.py" script that renames the package 
        "com.mytemplate.demo" to the package name specified in the "java_package" variable.
        
        ```python
        # sample tplate_finalize.py file
        
        import os
        import os.path
        import shutil
        
        
        def run(context):
        	from_dir = os.path.join(context['output_dir'],'src','main','java','com','mytemplate','demo')
        	to_dir = os.path.join( context['output_dir'],'src','main','java', *context['java_package'].split('.'))
        	shutil.copytree(from_dir, to_dir)
        	shutil.rmtree(from_dir)
        	remove_empty_dirs(os.path.join(context['output_dir'],'src','main','java'))
        
        def remove_empty_dirs(adir):
        	file_list = os.listdir(adir)
        	if len(file_list) == 0:
        		shutil.rmtree(adir)
        	else:
        		for f in file_list:
        			subdir = os.path.join(adir,f)
        			if os.path.isdir(subdir):
        				remove_empty_dirs(subdir)
        
        ```
        
        
        # Setup
        
        `pip install tplate`
        
        # Release Notes
        
        ## v1.0.3
        
        - added the "--update" flag to allow overwriting files in the output directory
        
        
Platform: UNKNOWN
Description-Content-Type: text/markdown
