├── .gitignore
├── LICENSE
├── README.md
├── RELEASE-NOTES.md
├── g8
    ├── cmd_new.go
    ├── cmd_scaffold.go
    ├── flags.go
    ├── main.go
    ├── main_test.go
    └── utils.go
├── git
    ├── clone.go
    └── git.go
├── go.mod
├── go.sum
├── release.sh
└── template
    ├── compat.go
    ├── compat_test.go
    ├── functions.go
    ├── functions_test.go
    ├── template.go
    └── template_test.go


/.gitignore:
--------------------------------------------------------------------------------
1 | # ignore binary
2 | /g8/g8
3 | .DS_Store
4 | /.idea/
5 | /.vscode/
6 | /vendor/
7 | /temp/
8 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Matt Ho
 4 | Copyright (c) 2019-2020 Thanh Nguyen
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # go-giter8
  2 | 
  3 | `btnguyen2k/go-giter8` is a fork of [`savaki/go-giter8`](https://github.com/savaki/go-giter8),
  4 | which is a command line tool to generate files and directories from templates published on git repository.
  5 | It's implemented in Go and can produce output for any purpose.
  6 | 
  7 | Features:
  8 | - [x] Generate template output from any git repository.
  9 | - [x] Generate template outout from a specific git branch or tag.
 10 | - [x] Generate template output from local directory (protocol `file://`).
 11 | - [x] Support scaffolding.
 12 | 
 13 | Latest version: [v0.6.0](RELEASE-NOTES.md).
 14 | 
 15 | ## Installation
 16 | 
 17 | > `go-giter8` is go-module enabled. Therefore, it must be installed/upgraded in go-module mode by setting `GO111MODULE=on`.
 18 | 
 19 | You can install `go-giter8` using the standard go deployment tool. This will install g8 as ```$GOPATH/bin/g8```:
 20 | 
 21 | ```
 22 | export GO111MODULE=on && go get github.com/btnguyen2k/go-giter8/g8
 23 | ```
 24 | 
 25 | or you can specified a specific version:
 26 | 
 27 | ```
 28 | export GO111MODULE=on && go get github.com/btnguyen2k/go-giter8/g8@v0.6.0
 29 | ```
 30 | 
 31 | ### Upgrading 
 32 | 
 33 | At any point you can upgrade `g8` using the following:
 34 | 
 35 | ```
 36 | export GO111MODULE=on && go get -u github.com/btnguyen2k/go-giter8/g8
 37 | ```
 38 | 
 39 | or you can specified a specific version:
 40 | 
 41 | ```
 42 | export GO111MODULE=on && go get -u github.com/btnguyen2k/go-giter8/g8@v0.6.0
 43 | ```
 44 | 
 45 | ## Giter8 template
 46 | 
 47 | For information on Giter8 templates, please see [http://www.foundweekends.org/giter8/](http://www.foundweekends.org/giter8/).
 48 | 
 49 | Summary of a Giter8 template project structure:
 50 | 
 51 | ```
 52 | <root>/
 53 | └── src/main/
 54 |     ├── g8/
 55 |     │   └── <template source files & directories>
 56 |     └── scaffolds/
 57 |         ├── <name1>/
 58 |         │   ├── default.properties
 59 |         │   └── <source files & directories of scaffold 1>
 60 |         ├── <name2>/
 61 |         │   ├── default.properties
 62 |         │   └── <source files & directories of scaffold 2>
 63 |         │   ...
 64 |         └── <nameN>/
 65 |             ├── default.properties
 66 |             └── <source files & directories of scaffold N>
 67 | ```
 68 | 
 69 | ## Usage
 70 | 
 71 | A template must reside in a git repository and be named with the suffix `.g8`. The syntax of `go-giter8` is slightly different from the original [giter8](https://github.com/n8han/giter8).
 72 | 
 73 | Sample template: [btnguyen2k/go-giter8-sample.g8](https://github.com/btnguyen2k/go-giter8-sample.g8).
 74 | 
 75 | ### New Project
 76 | 
 77 | To create a new project from a template, for example, [btnguyen2k/go-giter8-sample.g8](https://github.com/btnguyen2k/go-giter8-sample.g8):
 78 | 
 79 | ```
 80 | $ g8 new btnguyen2k/go-giter8-sample.g8
 81 | ```
 82 | 
 83 | A specific `branch` or `tag` can be use with syntax `@tagOrBranchName`:
 84 | 
 85 | ```
 86 | $ g8 new btnguyen2k/go-giter8-sample.g8@branchName
 87 | 
 88 | or
 89 | 
 90 | $ g8 new btnguyen2k/go-giter8-sample.g8@tagName
 91 | ```
 92 | 
 93 | By default, the template is cloned from [Github](https://github.com). Use full repo url to create project from a template resided in other git server:
 94 | 
 95 | ```
 96 | $ g8 new https://gitlab.com/btnguyen2k/go-giter8-sample.g8
 97 | 
 98 | or
 99 | 
100 | $ g8 new https://gitlab.com/btnguyen2k/go-giter8-sample.g8@branchName
101 | 
102 | or
103 | 
104 | $ g8 new https://gitlab.com/btnguyen2k/go-giter8-sample.g8@tagName
105 | ```
106 | 
107 | `go-giter8` uses your git binary (from default location `/usr/bin/git`) underneath the hood so any settings you've applied to git will also be picked up by `g8`.
108 | If git binary is not installed at the default location, specify the git binary with `--git /path/to/git`.
109 | 
110 | `go-giter8` can also generate template output from local directory (useful when testing template before publishing):
111 | 
112 | ```
113 | $ g8 new file:///home/btnguyen2k/workspace/go-giter8-sample.g8
114 | ```
115 | 
116 | > Files & directories under `/src/main/g8/` are used to generate project.
117 | 
118 | > Scaffolds under `/src/main/scaffolds/` are copied to `.g8/` under project's target directory.
119 | 
120 | Template placeholders and substitutions are defined in `default.properties` file. See section [Formatting Template Fields](#formatting_template_fields) below.
121 | 
122 | ### Scaffolding
123 | 
124 | Scaffolds can be generated by standing at generated project's root directory and run the following command:
125 | 
126 | ```
127 | $ g8 scaffold <scafold-name>
128 | ```
129 | 
130 | For example:
131 | 
132 | ```
133 | $ g8 scaffold bodao_mysql
134 | ```
135 | 
136 | > Scaffold placeholders and substitutions are defined in `default.properties` files. See section [Formatting Template Fields](#formatting_template_fields) below.
137 | 
138 | Scaffolding is available since [v0.4.0](RELEASE-NOTES.md).
139 | 
140 | ## Formatting Template Fields
141 | 
142 | `go-giter8` has built-in support for formatting template fields. Formatting options can be added when referencing fields. For example, the name field can be formatted in upper camel case with:
143 | 
144 | ```
145 | $name;format="Camel"$
146 | ```
147 | 
148 | If `name` field has value `myName`, the above formatting will transform to `MyName`.
149 | 
150 | The formatting options are:
151 | 
152 |     FuncName | Alternative Name
153 |     ---------|--------------------------------------------------------------------------------
154 |     upper    | uppercase       : all uppercase letters
155 |     lower    | lowercase       : all lowercase letters
156 |     cap      | capitalize      : uppercase first letter
157 |     decap    | decapitalize    : lowercase first letter
158 |     start    |                 : uppercase the first letter of each word
159 |     word     |                 : remove all non-word letters (only a-zA-Z0-9_)
160 |     Camel    |                 : upper camel case (start-case, word-only)
161 |     camel    |                 : lower camel case (start-case, word-only, decapitalize)
162 |     hyphen   | hyphenate       : replace spaces with hyphens
163 |     norm     | normalize       : all lowercase with hyphens (lowercase, hyphenate)
164 |     snake    |                 : replace spaces and dots with underscores
165 |     packaged |                 : replace dots with slashes (net.databinder -> net/databinder)
166 |     random   |                 : appends random characters to the given string
167 | 
168 | > Project level fields are defined in `/src/main/g8/default.properties` file.
169 | 
170 | > Scaffold level fields are defined in `/src/main/scaffolds/<scaffold-name>/default.properties` file.
171 | 
172 | Sample of `default.properties`:
173 | 
174 | ```
175 | description  = This template generates a microservices project in Go using Echo framework.
176 | verbatim     = .DS_Store .gitignore .gitlab-ci.yml go.mod go.sum release.sh public/* vendor/* views/*
177 | 
178 | name         = go_echo-microservices-seed
179 | shortname    = gems
180 | desc         = Microservices project template for Go using Echo
181 | organization = com.github.btnguyen2k
182 | app_author   = Thanh Nguyen <btnguyen2k@gmail.com>
183 | app_version  = 0.1.0
184 | timezone     = Asia/Ho_Chi_Minh
185 | ```
186 | 
187 | Special fields:
188 | - `description`: description of the template. It will be excluded from substitution list.
189 | - `verbatim`: list of file patterns (separated by space, comma, semi-colon or colon) such as `*.gif,*.png *.ico`. Files matching verbatim pattern are excluded from string template processing. `verbatim` field will be excluded from substitution list.
190 | - `name`: it is used as the name of a project being created. `go-giter8` creates a project directory based off that name (normalized) that will contain the template output.
191 | 
192 | > It is recommended that name follows the format `[a-zA-Z0-9]+` (only numbers and character).
193 | > Use `camelCase` to separate words (not underscores!).
194 | 


--------------------------------------------------------------------------------
/RELEASE-NOTES.md:
--------------------------------------------------------------------------------
 1 | # go-giter8 release notes
 2 | 
 3 | ## 2020-10-28 - v0.6.0
 4 | 
 5 | - AB#30: Support creating project from templates located at specific git branches or tags.
 6 | 
 7 | 
 8 | ## 2020-09-09 - v0.5.1
 9 | 
10 | - AB#24: `scaffold` command supports "quiet" mode.
11 | 
12 | 
13 | ## 2020-09-07 - v0.5.0
14 | 
15 | - AB#24: Support "quiet" mode.
16 | - Other fixes and enhancements.
17 | 
18 | 
19 | ## 2020-02-10 - v0.4.3
20 | 
21 | - Fix: incorrect file matching on Windows.
22 | 
23 | 
24 | ## 2020-01-20 - v0.4.2
25 | 
26 | - Fix: filename of file in "verbatim" list is kept intact.
27 | - Fix: `text/template`'s default delims (`{{` and `}}`) may cause issue sometimes.
28 | - Other bug fixes.
29 | 
30 | 
31 | ## 2020-01-01 - v0.4.0
32 | 
33 | - Support scaffolding & `scaffold` command.
34 | 
35 | 
36 | ## 2019-12-30 - v0.3.2
37 | 
38 | - Enhance "verbatim" list: support files under specific directories.
39 | 
40 | 
41 | ## 2019-11-25 - v0.3.1
42 | 
43 | - Fix bug: input with spaces is not treated as a whole string.
44 | 
45 | 
46 | ## 2019-09-19 - v0.3.0
47 | 
48 | - Generate template output from any git repository.
49 | - Remove temp directory after template output is generated successfully.
50 | - Generate template output from local directory (protocol `file://`).
51 | - Other fixes and improvements.
52 | 
53 | 
54 | ## 2019-09-11 - v0.2.0.1
55 | 
56 | - Migrate to use package `github.com/urfave/cli`.
57 | 
58 | 
59 | ## 2019-09-10 - v0.2.0
60 | 
61 | - Forked from [savaki/go-giter8](https://github.com/savaki/go-giter8).
62 | - Fixed bug: `unrecognized import path "code.google.com/p/go-uuid/uuid"`.
63 | - Clearly document that currently `go-giter8` supports only templates from GitHub.
64 | - Removed non-identifier transform functions to be compatible with package `text/template`.
65 | 


--------------------------------------------------------------------------------
/g8/cmd_new.go:
--------------------------------------------------------------------------------
  1 | // The MIT License (MIT)
  2 | //
  3 | // Copyright (c) 2014 Matt Ho
  4 | //
  5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | // of this software and associated documentation files (the "Software"), to deal
  7 | // in the Software without restriction, including without limitation the rights
  8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | // copies of the Software, and to permit persons to whom the Software is
 10 | // furnished to do so, subject to the following conditions:
 11 | //
 12 | // The above copyright notice and this permission notice shall be included in all
 13 | // copies or substantial portions of the Software.
 14 | //
 15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 | // SOFTWARE.
 22 | 
 23 | package main
 24 | 
 25 | import (
 26 | 	"errors"
 27 | 	"fmt"
 28 | 	"io/ioutil"
 29 | 	"net/url"
 30 | 	"os"
 31 | 	"path/filepath"
 32 | 	"regexp"
 33 | 	"strings"
 34 | 
 35 | 	"github.com/urfave/cli"
 36 | 
 37 | 	"github.com/btnguyen2k/go-giter8/template"
 38 | )
 39 | 
 40 | var commandNew = cli.Command{
 41 | 	Name:        "new",
 42 | 	ShortName:   "n",
 43 | 	Usage:       "Create a new project",
 44 | 	Description: "Create a new project from giter8 template located on GitHub, repository must be in format <username>/<repo-name-ends-with.g8>",
 45 | 	Flags: []cli.Flag{
 46 | 		flagGit,
 47 | 		flagNoInputs,
 48 | 		flagVerbose,
 49 | 	},
 50 | 	Action: newAction,
 51 | }
 52 | 
 53 | // handle command "new"
 54 | func newAction(c *cli.Context) {
 55 | 	opts := Opts(c)
 56 | 	if strings.TrimSpace(opts.Repo) == "" {
 57 | 		exitIfError(errors.New("ERROR - no template repo specified"))
 58 | 	}
 59 | 	// extract the repo
 60 | 	repo, err := url.Parse(opts.Repo)
 61 | 	exitIfError(err)
 62 | 	if repo.Scheme == "" {
 63 | 		repo.Scheme = "https"
 64 | 	}
 65 | 	if repo.Host == "" && repo.Scheme != "file" {
 66 | 		repo.Host = "github.com" // template are fetched from github by default
 67 | 	}
 68 | 	repo.Path = strings.TrimSuffix(repo.Path, "/")
 69 | 	exitIfError(exportGitRepo(opts, repo))
 70 | 
 71 | 	// load parameters
 72 | 	fields, err := readFieldsFromG8Template(opts, repo)
 73 | 	exitIfError(err)
 74 | 
 75 | 	// render the contents
 76 | 	exitIfError(newProject(opts, repo, fields))
 77 | 
 78 | 	if repo.Scheme != "file" {
 79 | 		exitIfError(cleanDir(relativePathToTemp(userAndRepoNames(repo))))
 80 | 	}
 81 | }
 82 | 
 83 | // create new project from template
 84 | func newProject(opts *Options, repo *url.URL, fields map[string]string) error {
 85 | 	delete(fields, "description") // remove system field "description"
 86 | 
 87 | 	target := template.Normalize(fields["name"])
 88 | 	if target == "" {
 89 | 		return errors.New("no [name] parameter defined")
 90 | 	}
 91 | 
 92 | 	var verbatim []string
 93 | 	if val, ok := fields["verbatim"]; ok && val != "" {
 94 | 		verbatim = regexp.MustCompile("[,;:\\s]+").Split(fields["verbatim"], -1)
 95 | 	}
 96 | 	delete(fields, "verbatim") // remove system field "verbatim"
 97 | 
 98 | 	var codeBase, scaffoldsBase string
 99 | 	if repo.Scheme == "file" {
100 | 		codeBase = repo.Path + "/src/main/g8"
101 | 		scaffoldsBase = repo.Path + "/src/main/scaffolds"
102 | 	} else {
103 | 		codeBase = relativePathToTemp(userAndRepoNames(repo), "src/main/g8")
104 | 		scaffoldsBase = relativePathToTemp(userAndRepoNames(repo), "src/main/scaffolds")
105 | 	}
106 | 
107 | 	// copy scaffolds
108 | 	if pathExists(scaffoldsBase) {
109 | 		fmt.Printf("Copying scaffolds...")
110 | 		if opts.Verbose {
111 | 			fmt.Println()
112 | 		}
113 | 		if err := copyDir(opts, scaffoldsBase, target+"/.g8"); err != nil {
114 | 			return err
115 | 		}
116 | 		if !opts.Verbose {
117 | 			fmt.Printf("done.\n")
118 | 		}
119 | 	}
120 | 
121 | 	// create project structure from template
122 | 	fmt.Printf("Generating project...")
123 | 	if opts.Verbose {
124 | 		fmt.Println()
125 | 	}
126 | 	prefixLen := len(codeBase)
127 | 	err := filepath.Walk(codeBase, func(path string, f os.FileInfo, err error) error {
128 | 		if f.IsDir() || f.Name() == "default.properties" {
129 | 			return nil
130 | 		}
131 | 
132 | 		relativePath := path[prefixLen:] // relativePathToTemp is absolute; let's strip off the prefix
133 | 		var destFileName = target + relativePath
134 | 		// transform filename if not in "verbatim" list
135 | 		if !isFileMatched(relativePath, f, verbatim) {
136 | 			destFileName, err = transformFilename(destFileName, fields)
137 | 			if err != nil {
138 | 				return err
139 | 			}
140 | 		}
141 | 
142 | 		// ensure the directory exists
143 | 		if err = mkdir(filepath.Dir(destFileName), 0755); err != nil {
144 | 			return err
145 | 		}
146 | 
147 | 		if opts.Verbose {
148 | 			fmt.Printf("\tgenerating %s...", destFileName)
149 | 		}
150 | 		// load file content
151 | 		inContent, err := ioutil.ReadFile(path)
152 | 		if err != nil {
153 | 			if opts.Verbose {
154 | 				fmt.Printf("error.\n")
155 | 			}
156 | 			return err
157 | 		}
158 | 		outContent := inContent
159 | 
160 | 		// transform content if not in "verbatim" list
161 | 		if !isFileMatched(relativePath, f, verbatim) {
162 | 			outContent, err = template.Render(inContent, fields)
163 | 			if err != nil {
164 | 				if opts.Verbose {
165 | 					fmt.Printf("error.\n")
166 | 				}
167 | 				return err
168 | 			}
169 | 		}
170 | 		err = ioutil.WriteFile(destFileName, outContent, f.Mode())
171 | 		if opts.Verbose {
172 | 			if err != nil {
173 | 				fmt.Printf("error.\n")
174 | 			} else {
175 | 				fmt.Printf("done.\n")
176 | 			}
177 | 		}
178 | 		return err
179 | 	})
180 | 	if !opts.Verbose {
181 | 		if err != nil {
182 | 			fmt.Printf("error.\n")
183 | 		} else {
184 | 			fmt.Printf("done.\n")
185 | 		}
186 | 	}
187 | 	return err
188 | }
189 | 


--------------------------------------------------------------------------------
/g8/cmd_scaffold.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"io/ioutil"
  7 | 	"os"
  8 | 	"path/filepath"
  9 | 	"regexp"
 10 | 	"strings"
 11 | 
 12 | 	"github.com/urfave/cli"
 13 | 
 14 | 	"github.com/btnguyen2k/go-giter8/template"
 15 | )
 16 | 
 17 | var commandScaffold = cli.Command{
 18 | 	Name:        "scaffold",
 19 | 	ShortName:   "sf",
 20 | 	Usage:       "Generate files from a scaffolding",
 21 | 	Description: "Generate files from a giter8 scaffold",
 22 | 	Flags: []cli.Flag{
 23 | 		flagNoInputs,
 24 | 		flagVerbose,
 25 | 	},
 26 | 	Action: scaffoldAction,
 27 | }
 28 | 
 29 | // handle command "scaffold"
 30 | func scaffoldAction(c *cli.Context) {
 31 | 	exitIfError(generateScaffold(Opts(c)))
 32 | }
 33 | 
 34 | func generateScaffold(opts *Options) error {
 35 | 	scaffoldName := strings.TrimSpace(opts.ScaffoldName)
 36 | 	if scaffoldName == "" {
 37 | 		return errors.New("ERROR - no scaffold name specified")
 38 | 	}
 39 | 	srcDir := ".g8/" + scaffoldName
 40 | 	if !isDir(srcDir) {
 41 | 		return errors.New("ERROR - [" + srcDir + "] not readable, or not a directory")
 42 | 	}
 43 | 	// must stand at project's root directory
 44 | 	destDir := "."
 45 | 
 46 | 	// load parameters
 47 | 	fields, err := readFieldsFromFile(opts, srcDir+"/default.properties")
 48 | 	exitIfError(err)
 49 | 
 50 | 	delete(fields, "description") // remove system field "description"
 51 | 	var verbatim []string
 52 | 	if val, ok := fields["verbatim"]; ok && val != "" {
 53 | 		verbatim = regexp.MustCompile("[,;:\\s]+").Split(fields["verbatim"], -1)
 54 | 	}
 55 | 	delete(fields, "verbatim") // remove system field "verbatim"
 56 | 
 57 | 	// generate scaffold
 58 | 	fmt.Printf("Generating scaffold %s...", scaffoldName)
 59 | 	if opts.Verbose {
 60 | 		fmt.Println()
 61 | 	}
 62 | 	prefixLen := len(srcDir)
 63 | 	err = filepath.Walk(srcDir, func(path string, f os.FileInfo, err error) error {
 64 | 		if f.IsDir() || f.Name() == "default.properties" {
 65 | 			return nil
 66 | 		}
 67 | 
 68 | 		relativePath := path[prefixLen:]
 69 | 		destFileName, err := transformFilename(destDir+relativePath, fields)
 70 | 		if err != nil {
 71 | 			return err
 72 | 		}
 73 | 		// ensure the directory exists
 74 | 		if err = mkdir(filepath.Dir(destFileName), 0755); err != nil {
 75 | 			return err
 76 | 		}
 77 | 
 78 | 		if opts.Verbose {
 79 | 			fmt.Printf("\tgenerating %s...", destFileName)
 80 | 		}
 81 | 		// load file content
 82 | 		inContent, err := ioutil.ReadFile(path)
 83 | 		if err != nil {
 84 | 			if opts.Verbose {
 85 | 				fmt.Printf("error.\n")
 86 | 			}
 87 | 			return err
 88 | 		}
 89 | 		outContent := inContent
 90 | 
 91 | 		// transform content if not in "verbatim" list
 92 | 		if !isFileMatched(relativePath, f, verbatim) {
 93 | 			outContent, err = template.Render(inContent, fields)
 94 | 			if err != nil {
 95 | 				if opts.Verbose {
 96 | 					fmt.Printf("error.\n")
 97 | 				}
 98 | 				return err
 99 | 			}
100 | 		}
101 | 		err = ioutil.WriteFile(destFileName, outContent, f.Mode())
102 | 		if opts.Verbose {
103 | 			if err != nil {
104 | 				fmt.Printf("error.\n")
105 | 			} else {
106 | 				fmt.Printf("done.\n")
107 | 			}
108 | 		}
109 | 		return err
110 | 	})
111 | 	if !opts.Verbose {
112 | 		if err != nil {
113 | 			fmt.Printf("error.\n")
114 | 		} else {
115 | 			fmt.Printf("done.\n")
116 | 		}
117 | 	}
118 | 	return err
119 | }
120 | 


--------------------------------------------------------------------------------
/g8/flags.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package main
24 | 
25 | import (
26 | 	"github.com/urfave/cli"
27 | )
28 | 
29 | const (
30 | 	fieldGit      = "git"
31 | 	fieldNoInputs = "no-inputs"
32 | 	fieldVerbose  = "verbose"
33 | )
34 | 
35 | var (
36 | 	flagGit      = cli.StringFlag{Name: fieldGit, Value: "/usr/bin/git", Usage: "relativePathToTemp to the git binary", EnvVar: "GIT"}
37 | 	flagNoInputs = cli.BoolFlag{Name: fieldNoInputs, Usage: "do not ask for input, accept all default values from default.properties"}
38 | 	flagVerbose  = cli.BoolFlag{Name: fieldVerbose, Usage: "additional debugging"}
39 | )
40 | 
41 | // var Verbose bool
42 | 
43 | type Options struct {
44 | 	NoInputs     bool
45 | 	Verbose      bool
46 | 	Git          string
47 | 	Repo         string
48 | 	ScaffoldName string
49 | }
50 | 
51 | func Opts(c *cli.Context) *Options {
52 | 	// Verbose = c.Bool(fieldVerbose)
53 | 	return &Options{
54 | 		NoInputs:     c.Bool(fieldNoInputs),
55 | 		Verbose:      c.Bool(fieldVerbose),
56 | 		Git:          c.String(fieldGit),
57 | 		Repo:         c.Args().First(),
58 | 		ScaffoldName: c.Args().First(),
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/g8/main.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package main
24 | 
25 | import (
26 | 	"github.com/urfave/cli"
27 | 	"os"
28 | )
29 | 
30 | const (
31 | 	// Version of go-giter8
32 | 	Version = "0.6.0"
33 | )
34 | 
35 | func main() {
36 | 	app := cli.NewApp()
37 | 	app.Name = "giter8"
38 | 	app.Usage = "Generate templates from GitHub"
39 | 	app.Version = Version
40 | 	app.Commands = []cli.Command{
41 | 		commandNew,
42 | 		commandScaffold,
43 | 	}
44 | 	app.Run(os.Args)
45 | }
46 | 


--------------------------------------------------------------------------------
/g8/main_test.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package main
24 | 
25 | import (
26 | 	"testing"
27 | )
28 | 
29 | func TestCompiles(t *testing.T) {
30 | }
31 | 


--------------------------------------------------------------------------------
/g8/utils.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"io/ioutil"
  8 | 	"net/url"
  9 | 	"os"
 10 | 	"path/filepath"
 11 | 	"runtime"
 12 | 	"strings"
 13 | 
 14 | 	"github.com/gobwas/glob"
 15 | 	"github.com/savaki/properties"
 16 | 
 17 | 	"github.com/btnguyen2k/go-giter8/git"
 18 | 	"github.com/btnguyen2k/go-giter8/template"
 19 | )
 20 | 
 21 | // exitIfError terminates application in case of error
 22 | func exitIfError(err error) {
 23 | 	if err != nil {
 24 | 		panic(err)
 25 | 		// log.Fatalln(err)
 26 | 	}
 27 | }
 28 | 
 29 | // pathExists checks if a file/directory pathExists
 30 | func pathExists(path string) bool {
 31 | 	_, err := os.Stat(path)
 32 | 	return !os.IsNotExist(err)
 33 | }
 34 | 
 35 | func isDir(path string) bool {
 36 | 	fi, err := os.Stat(path)
 37 | 	switch {
 38 | 	case err != nil:
 39 | 		return false
 40 | 	default:
 41 | 		return fi.IsDir()
 42 | 	}
 43 | }
 44 | 
 45 | // cleanDir removes directory and all its content
 46 | func cleanDir(tempDir string) error {
 47 | 	if pathExists(tempDir) {
 48 | 		return os.RemoveAll(tempDir)
 49 | 	}
 50 | 	return nil
 51 | }
 52 | 
 53 | // exportGitRepo exports a git repo to local directory
 54 | // - gitBinary: git's executable binary file
 55 | // - repo: format [<https://host:port/>]<username>/repo-name-ends-with.g8>[@branchOrTagName],
 56 | //     example https://github.com/btnguyen2k/go_echo-microservices-seed.g8@template-v0.4.r1
 57 | //     if <https://host:port/> is not provided, https://github.com/ is assumed
 58 | func exportGitRepo(opts *Options, repo *url.URL) error {
 59 | 	if repo.Scheme == "file" {
 60 | 		// @branch or @tag is not supported with local files
 61 | 		return nil
 62 | 	}
 63 | 
 64 | 	gitBinary := opts.Git
 65 | 	userAndRepoNames := userAndRepoNames(repo)
 66 | 	dirOut := relativePathToTemp(userAndRepoNames)
 67 | 	err := cleanDir(dirOut)
 68 | 	if err != nil {
 69 | 		return err
 70 | 	}
 71 | 
 72 | 	tokens := strings.Split(userAndRepoNames, "/")
 73 | 	if len(tokens) != 2 || !strings.HasSuffix(tokens[1], ".g8") {
 74 | 		return errors.New("repository must be in format [<https://host:port/>]<username>/repo-name-ends-with.g8>")
 75 | 	}
 76 | 
 77 | 	user := tokens[0]
 78 | 	client := git.New(gitBinary, relativePathToTemp(user))
 79 | 	client.Verbose = opts.Verbose
 80 | 	return client.Clone(repo.String(), tagOrBranchName(repo))
 81 | 	// return client.Export(repo, tagOrBranchName(repo))
 82 | }
 83 | 
 84 | // userAndRepoNames extracts the <username/repo-name> part from repository url
 85 | func userAndRepoNames(url *url.URL) string {
 86 | 	userAndRepoNames := url.Path
 87 | 	if i := strings.LastIndex(userAndRepoNames, "@"); i >= 0 {
 88 | 		userAndRepoNames = userAndRepoNames[0:i]
 89 | 	}
 90 | 	if strings.HasPrefix(userAndRepoNames, "/") {
 91 | 		userAndRepoNames = userAndRepoNames[1:]
 92 | 	}
 93 | 	return userAndRepoNames
 94 | }
 95 | 
 96 | // tagOrBranchName extract the tag/branch name part from repository url.
 97 | // tagOrBranchName is suffixed to the repository url after @ character.
 98 | func tagOrBranchName(url *url.URL) string {
 99 | 	tagOrBranchName := ""
100 | 	if i := strings.LastIndex(url.Path, "@"); i >= 0 {
101 | 		tagOrBranchName = url.Path[i+1:]
102 | 	}
103 | 	return tagOrBranchName
104 | }
105 | 
106 | // relativePathToTemp creates relative path to our temporary storage location
107 | func relativePathToTemp(dirs ...string) string {
108 | 	subdir := strings.Join(dirs, "/")
109 | 	return fmt.Sprintf("%s/.go-giter8/%s", os.Getenv("HOME"), subdir)
110 | }
111 | 
112 | // readFieldsFromFile reads fields/values from file (".properties" format)
113 | func readFieldsFromFile(opts *Options, path string) (map[string]string, error) {
114 | 	if opts.Verbose {
115 | 		fmt.Printf("Loading parameters from file %s...", path)
116 | 	}
117 | 	props, err := properties.LoadFile(path, properties.UTF8)
118 | 	if err != nil {
119 | 		if opts.Verbose {
120 | 			fmt.Printf("error.\n")
121 | 		}
122 | 		return map[string]string{}, nil
123 | 	}
124 | 	if opts.Verbose {
125 | 		fmt.Printf("done.\n")
126 | 	}
127 | 
128 | 	// print out "description" if any
129 | 	if desc := props.GetString("description", ""); desc != "" {
130 | 		fmt.Printf("\t%s\n", desc)
131 | 	}
132 | 
133 | 	fmt.Printf("Customizing parameters: ")
134 | 	if opts.NoInputs {
135 | 		fmt.Printf("skipped.\n")
136 | 	} else {
137 | 		fmt.Printf("\n")
138 | 	}
139 | 	// ask the user for input on each of the fields
140 | 	fields := map[string]string{}
141 | 	scanner := bufio.NewScanner(os.Stdin)
142 | 	for _, key := range props.Keys() {
143 | 		if key == "" {
144 | 			continue
145 | 		}
146 | 		defaultValue := props.GetString(key, "")
147 | 		var value string
148 | 		if key != "verbatim" && key != "description" && !opts.NoInputs {
149 | 			// do not ask for input for 'system' fields
150 | 			fmt.Printf("\t%s [%s]: ", key, defaultValue)
151 | 			if scanner.Scan() {
152 | 				value = scanner.Text()
153 | 			}
154 | 		}
155 | 		if strings.TrimSpace(value) == "" {
156 | 			fields[key] = defaultValue
157 | 		} else {
158 | 			fields[key] = value
159 | 		}
160 | 	}
161 | 	return fields, nil
162 | }
163 | 
164 | // readFieldsFromG8Template reads fields/values from "default.properties" resided in a "giter8" template
165 | func readFieldsFromG8Template(opts *Options, repo *url.URL) (map[string]string, error) {
166 | 	var path string
167 | 	// assume giter8 format
168 | 	if repo.Scheme == "file" {
169 | 		path = repo.Path + "/src/main/g8/default.properties"
170 | 	} else {
171 | 		path = relativePathToTemp(userAndRepoNames(repo), "src/main/g8/default.properties")
172 | 	}
173 | 	return readFieldsFromFile(opts, path)
174 | }
175 | 
176 | func transformFilename(filename string, fields map[string]string) (string, error) {
177 | 	result, err := template.Render([]byte(filename), fields)
178 | 	if err != nil {
179 | 		return "", err
180 | 	}
181 | 	return string(result), nil
182 | }
183 | 
184 | func mkdir(target string, mode os.FileMode) error {
185 | 	if !pathExists(target) {
186 | 		return os.MkdirAll(target, mode)
187 | 	}
188 | 	return nil
189 | }
190 | 
191 | func copyDir(opts *Options, srcDir, destDir string) error {
192 | 	prefixLen := len(srcDir)
193 | 	return filepath.Walk(srcDir, func(path string, f os.FileInfo, err error) error {
194 | 		relativePath := path[prefixLen:]
195 | 		dest := destDir + relativePath
196 | 		if opts.Verbose {
197 | 			fmt.Printf("\tCopying %s -> %s\n", path, dest)
198 | 		}
199 | 		switch f.Mode() & os.ModeType {
200 | 		case os.ModeDir:
201 | 			return mkdir(dest, f.Mode())
202 | 		case os.ModeSymlink:
203 | 			if err := mkdir(filepath.Dir(dest), 0755); err != nil {
204 | 				return err
205 | 			}
206 | 			if link, err := os.Readlink(path); err != nil {
207 | 				return err
208 | 			} else {
209 | 				return os.Symlink(link, dest)
210 | 			}
211 | 		default:
212 | 			if err := mkdir(filepath.Dir(dest), 0755); err != nil {
213 | 				return err
214 | 			}
215 | 			if content, err := ioutil.ReadFile(path); err != nil {
216 | 				return err
217 | 			} else {
218 | 				return ioutil.WriteFile(dest, content, f.Mode())
219 | 			}
220 | 		}
221 | 		return nil
222 | 	})
223 | }
224 | 
225 | func isFileMatched(relativePath string, f os.FileInfo, matchList []string) bool {
226 | 	isWindows := strings.ToLower(runtime.GOOS) == "windows"
227 | 	if isWindows {
228 | 		relativePath = strings.TrimPrefix(relativePath, "\\")
229 | 	} else {
230 | 		relativePath = strings.TrimPrefix(relativePath, "/")
231 | 	}
232 | 
233 | 	for _, pattern := range matchList {
234 | 		if isWindows {
235 | 			pattern = strings.ReplaceAll(pattern, "/", "\\\\")
236 | 		} else {
237 | 			pattern = strings.ReplaceAll(pattern, "\\", "/")
238 | 		}
239 | 		if matched, _ := filepath.Match(pattern, f.Name()); matched {
240 | 			return true
241 | 		}
242 | 		if g := glob.MustCompile(pattern); g != nil && g.Match(relativePath) {
243 | 			return true
244 | 		}
245 | 	}
246 | 	return false
247 | }
248 | 


--------------------------------------------------------------------------------
/git/clone.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package git
24 | 
25 | import (
26 | 	"log"
27 | 	"os"
28 | 	"os/exec"
29 | 	"strings"
30 | )
31 | 
32 | func (g *Git) Clone(url, tagOrBranchName string) error {
33 | 	if i := strings.LastIndex(url, "@"); i >= 0 {
34 | 		url = url[0:i]
35 | 	}
36 | 	args := []string{"clone", url}
37 | 	if tagOrBranchName != "" {
38 | 		args = append(append(args, "--branch"), tagOrBranchName)
39 | 	}
40 | 	if g.Verbose {
41 | 		log.Printf("git %s\n", strings.Join(args, " "))
42 | 	}
43 | 	if _, err := os.Stat(g.TargetDir); os.IsNotExist(err) {
44 | 		os.MkdirAll(g.TargetDir, 0755)
45 | 	}
46 | 
47 | 	cmd := exec.Command(g.GitBinary, args...)
48 | 	cmd.Dir = g.TargetDir
49 | 	cmd.Stdout = os.Stdout
50 | 	cmd.Stderr = os.Stderr
51 | 	return cmd.Run()
52 | }
53 | 
54 | // func (g *Git) Export(repo *url.URL) error {
55 | // 	return g.Clone(repo.String() + ".git")
56 | // }
57 | 


--------------------------------------------------------------------------------
/git/git.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package git
24 | 
25 | type Git struct {
26 | 	GitBinary string
27 | 	TargetDir string
28 | 	Verbose   bool
29 | }
30 | 
31 | func New(gitBinary, targetDir string) *Git {
32 | 	return &Git{
33 | 		GitBinary: gitBinary,
34 | 		TargetDir: targetDir,
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/btnguyen2k/go-giter8
 2 | 
 3 | go 1.12
 4 | 
 5 | require (
 6 | 	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
 7 | 	github.com/gobwas/glob v0.2.3
 8 | 	github.com/google/uuid v1.1.1 // indirect
 9 | 	github.com/pborman/uuid v1.2.0
10 | 	github.com/savaki/properties v1.4.0
11 | 	github.com/urfave/cli v1.22.2
12 | 	launchpad.net/gocheck v0.0.0-20140225173054-000000000087 // indirect
13 | )
14 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 2 | github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY=
 3 | github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 4 | github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
 5 | github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 6 | github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 7 | github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 8 | github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
 9 | github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
10 | github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
11 | github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
12 | github.com/pborman/uuid v1.2.0 h1:J7Q5mO4ysT1dv8hyrUGHb9+ooztCXu1D8MY8DZYsu3g=
13 | github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
14 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
15 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
16 | github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
17 | github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
18 | github.com/savaki/properties v1.4.0 h1:1fuCeSn/NsvrmmEbdaoTr6D2v7MEH2BdtvlH84HbokI=
19 | github.com/savaki/properties v1.4.0/go.mod h1:oDX/ZAm38lXr5kfIaGOorkdI9HsYa7/4lnNMzUdMhps=
20 | github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
21 | github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
22 | github.com/urfave/cli v1.22.2 h1:gsqYFH8bb9ekPA12kRo0hfjngWQjkJPlN9R0N78BoUo=
23 | github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
24 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
25 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
26 | launchpad.net/gocheck v0.0.0-20140225173054-000000000087 h1:Izowp2XBH6Ya6rv+hqbceQyw/gSGoXfH/UPoTGduL54=
27 | launchpad.net/gocheck v0.0.0-20140225173054-000000000087/go.mod h1:hj7XX3B/0A+80Vse0e+BUHsHMTEhd0O4cpUHr/e/BUM=
28 | 


--------------------------------------------------------------------------------
/release.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | ## Utility script to release project with a tag
 4 | ## Usage:
 5 | ##   ./release.sh <tag-name>
 6 | 
 7 | if [ "$1" == "" ]; then
 8 | 	echo "Usage: $0 tag-name"
 9 | 	exit -1
10 | fi
11 | 
12 | echo "$1"
13 | git commit -m "$1"
14 | git tag -f -a "$1" -m "$1"
15 | git push origin "$1" -f
16 | git push
17 | 
18 | 


--------------------------------------------------------------------------------
/template/compat.go:
--------------------------------------------------------------------------------
 1 | // The MIT License (MIT)
 2 | //
 3 | // Copyright (c) 2014 Matt Ho
 4 | //
 5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // of this software and associated documentation files (the "Software"), to deal
 7 | // in the Software without restriction, including without limitation the rights
 8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in all
13 | // copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // SOFTWARE.
22 | 
23 | package template
24 | 
25 | import (
26 | 	"regexp"
27 | )
28 | 
29 | var (
30 | 	stringEscapeRe = regexp.MustCompile(`\\\$`)
31 | )
32 | 
33 | func giter8ify(text []byte) []byte {
34 | 	return stringEscapeRe.ReplaceAll(text, []byte(`$`))
35 | }
36 | 


--------------------------------------------------------------------------------
/template/compat_test.go:
--------------------------------------------------------------------------------
 1 | // // The MIT License (MIT)
 2 | // //
 3 | // // Copyright (c) 2014 Matt Ho
 4 | // //
 5 | // // Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | // // of this software and associated documentation files (the "Software"), to deal
 7 | // // in the Software without restriction, including without limitation the rights
 8 | // // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | // // copies of the Software, and to permit persons to whom the Software is
10 | // // furnished to do so, subject to the following conditions:
11 | // //
12 | // // The above copyright notice and this permission notice shall be included in all
13 | // // copies or substantial portions of the Software.
14 | // //
15 | // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | // // SOFTWARE.
22 | //
23 | package template
24 | //
25 | // import (
26 | // 	. "github.com/smartystreets/goconvey/convey"
27 | // 	"testing"
28 | // )
29 | //
30 | // func TestGiter8ify(t *testing.T) {
31 | // 	Convey("Given a string with escaped $", t, func() {
32 | // 		text := []byte(`-> \$ <-`)
33 | //
34 | // 		Convey("When I invoke #giter8ify", func() {
35 | // 			result := giter8ify(text)
36 | //
37 | // 			Convey("Then I expect the escaped $ to be unescaped", func() {
38 | // 				So(string(result), ShouldEqual, `-> $ <-`)
39 | // 			})
40 | // 		})
41 | // 	})
42 | // }
43 | 


--------------------------------------------------------------------------------
/template/functions.go:
--------------------------------------------------------------------------------
  1 | // The MIT License (MIT)
  2 | //
  3 | // Copyright (c) 2014 Matt Ho
  4 | //
  5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | // of this software and associated documentation files (the "Software"), to deal
  7 | // in the Software without restriction, including without limitation the rights
  8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | // copies of the Software, and to permit persons to whom the Software is
 10 | // furnished to do so, subject to the following conditions:
 11 | //
 12 | // The above copyright notice and this permission notice shall be included in all
 13 | // copies or substantial portions of the Software.
 14 | //
 15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 | // SOFTWARE.
 22 | 
 23 | package template
 24 | 
 25 | import (
 26 | 	"github.com/pborman/uuid"
 27 | 	"regexp"
 28 | 	"strings"
 29 | 	text_template "text/template"
 30 | )
 31 | 
 32 | var funcMap = text_template.FuncMap{
 33 | 	"upper":        Upper, // all uppercase letters
 34 | 	"uppercase":    Upper,
 35 | 	"lower":        Lower, // all lowercase letters
 36 | 	"lowercase":    Lower,
 37 | 	"cap":          Capitalize, // uppercase first letter
 38 | 	"capitalize":   Capitalize,
 39 | 	"decap":        Decapitalize, // lowercase first letter
 40 | 	"decapitalize": Decapitalize,
 41 | 	"start":        Start, // uppercase the first letter of each word
 42 | 	// "start-case":   Start,
 43 | 	"word": Word, // remove all non-word letters (only a-zA-Z0-9_)
 44 | 	// "word-only":    Word,
 45 | 	// "space":			Space,//replace all non-word letters (only a-zA-Z0-9) with a whitespace
 46 | 	// "word-space":		Space,
 47 | 	"Camel": Camel, // upper camel case (start-case, word-only)
 48 | 	// "upper-camel": Camel,
 49 | 	"camel": CamelLower, // lower camel case (start-case, word-only, decapitalize)
 50 | 	// "lower-camel": CamelLower,
 51 | 	"hyphen":    Hyphenate, // replace spaces with hyphens
 52 | 	"hyphenate": Hyphenate,
 53 | 	"norm":      Normalize, // all lowercase with hyphens (lowercase, hyphenate)
 54 | 	"normalize": Normalize,
 55 | 	"snake":     Snake, // replace spaces and dots with underscores
 56 | 	// "snake-case":  Snake,
 57 | 	// "package":         Package,//replace spaces with dots
 58 | 	// "package-naming":  Package,
 59 | 	"packaged": Packaged, // replace dots with slashes (net.databinder -> net/databinder)
 60 | 	// "packaged-dir":    Packaged,
 61 | 	"random": Random, // appends random characters to the given string
 62 | 	// "generate-random": Random,
 63 | }
 64 | 
 65 | var (
 66 | 	wordRe       = regexp.MustCompile(`\W`)
 67 | 	whitespaceRe = regexp.MustCompile(`\s`)
 68 | 	dotRe        = regexp.MustCompile(`\.`)
 69 | 	snakeRe      = regexp.MustCompile(`\.|\s`)
 70 | )
 71 | 
 72 | func Upper(value string) string {
 73 | 	return strings.ToUpper(value)
 74 | }
 75 | 
 76 | func Lower(value string) string {
 77 | 	return strings.ToLower(value)
 78 | }
 79 | 
 80 | func Word(value string) string {
 81 | 	return wordRe.ReplaceAllString(value, "")
 82 | }
 83 | 
 84 | func Capitalize(value string) string {
 85 | 	switch len(value) {
 86 | 	case 0:
 87 | 		return ""
 88 | 	case 1:
 89 | 		return strings.ToUpper(value[:1])
 90 | 	default:
 91 | 		return strings.ToUpper(value[:1]) + value[1:]
 92 | 	}
 93 | }
 94 | 
 95 | func Decapitalize(value string) string {
 96 | 	switch len(value) {
 97 | 	case 0:
 98 | 		return ""
 99 | 	case 1:
100 | 		return strings.ToLower(value[:1])
101 | 	default:
102 | 		return strings.ToLower(value[:1]) + value[1:]
103 | 	}
104 | }
105 | 
106 | func Start(value string) string {
107 | 	parts := strings.Split(value, " ")
108 | 	capped := []string{}
109 | 
110 | 	for _, part := range parts {
111 | 		capped = append(capped, Capitalize(part))
112 | 	}
113 | 
114 | 	return strings.Join(capped, " ")
115 | }
116 | 
117 | func Camel(value string) string {
118 | 	value = Start(value)
119 | 	return Word(value)
120 | }
121 | 
122 | func CamelLower(value string) string {
123 | 	value = Camel(value)
124 | 	return Decapitalize(value)
125 | }
126 | 
127 | func Normalize(value string) string {
128 | 	value = Hyphenate(value)
129 | 	return strings.ToLower(value)
130 | }
131 | 
132 | func Hyphenate(value string) string {
133 | 	return whitespaceRe.ReplaceAllString(value, "-")
134 | }
135 | 
136 | func Packaged(value string) string {
137 | 	return dotRe.ReplaceAllString(value, "/")
138 | }
139 | 
140 | func Snake(value string) string {
141 | 	return snakeRe.ReplaceAllString(value, "_")
142 | }
143 | 
144 | func Random(value string) string {
145 | 	return value + Word(uuid.NewRandom().String())
146 | }
147 | 


--------------------------------------------------------------------------------
/template/functions_test.go:
--------------------------------------------------------------------------------
  1 | // // The MIT License (MIT)
  2 | // //
  3 | // // Copyright (c) 2014 Matt Ho
  4 | // //
  5 | // // Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | // // of this software and associated documentation files (the "Software"), to deal
  7 | // // in the Software without restriction, including without limitation the rights
  8 | // // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | // // copies of the Software, and to permit persons to whom the Software is
 10 | // // furnished to do so, subject to the following conditions:
 11 | // //
 12 | // // The above copyright notice and this permission notice shall be included in all
 13 | // // copies or substantial portions of the Software.
 14 | // //
 15 | // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | // // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | // // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | // // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | // // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | // // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 | // // SOFTWARE.
 22 | //
 23 | package template
 24 | //
 25 | // import (
 26 | // 	. "github.com/smartystreets/goconvey/convey"
 27 | // 	"testing"
 28 | // )
 29 | //
 30 | // func TestCapitalize(t *testing.T) {
 31 | // 	Convey("When I #Capitalize a string", t, func() {
 32 | // 		result := Capitalize("hello")
 33 | //
 34 | // 		Convey("Then only the first letter is capitalized", func() {
 35 | // 			So(result, ShouldEqual, "Hello")
 36 | // 		})
 37 | // 	})
 38 | //
 39 | // 	Convey("I can #Capitalize a zero lengthed string", t, func() {
 40 | // 		So(Capitalize(""), ShouldEqual, "")
 41 | // 	})
 42 | //
 43 | // 	Convey("I can #Capitalize a string of length 1", t, func() {
 44 | // 		So(Capitalize("h"), ShouldEqual, "H")
 45 | // 	})
 46 | // }
 47 | //
 48 | // func TestDecapitalize(t *testing.T) {
 49 | // 	Convey("When I #Decapitalize a string", t, func() {
 50 | // 		result := Decapitalize("HELLO")
 51 | //
 52 | // 		Convey("Then only the first letter is de-capitalized", func() {
 53 | // 			So(result, ShouldEqual, "hELLO")
 54 | // 		})
 55 | // 	})
 56 | //
 57 | // 	Convey("I can #Decapitalize a zero lengthed string", t, func() {
 58 | // 		So(Decapitalize(""), ShouldEqual, "")
 59 | // 	})
 60 | //
 61 | // 	Convey("I can #Capitalize a string of length 1", t, func() {
 62 | // 		So(Decapitalize("H"), ShouldEqual, "h")
 63 | // 	})
 64 | // }
 65 | //
 66 | // func TestPackaged(t *testing.T) {
 67 | // 	Convey("#Packaged replaces dots with slashes", t, func() {
 68 | // 		So(Packaged("com.loyal3.foo"), ShouldEqual, "com/loyal3/foo")
 69 | // 	})
 70 | // }
 71 | //
 72 | // func TestRandom(t *testing.T) {
 73 | // 	Convey("When I #Random a string", t, func() {
 74 | // 		result := Random("hello")
 75 | // 		So(len(result), ShouldBeGreaterThan, len("hello"))
 76 | // 	})
 77 | // }
 78 | //
 79 | // func TestUpper(t *testing.T) {
 80 | // 	Convey("When I #Upper a string", t, func() {
 81 | // 		result := Upper("hello world")
 82 | // 		Convey("Then I expect all upper cases", func() {
 83 | // 			So(result, ShouldEqual, "HELLO WORLD")
 84 | // 		})
 85 | // 	})
 86 | // }
 87 | //
 88 | // func TestLower(t *testing.T) {
 89 | // 	Convey("When I #Lower a string", t, func() {
 90 | // 		result := Lower("Hello WORLD")
 91 | // 		Convey("Then I expect all lower cases", func() {
 92 | // 			So(result, ShouldEqual, "hello world")
 93 | // 		})
 94 | // 	})
 95 | // }
 96 | //
 97 | // func TestStart(t *testing.T) {
 98 | // 	Convey("When I #Start a string", t, func() {
 99 | // 		result := Start("hello world")
100 | // 		So(result, ShouldEqual, "Hello World")
101 | // 	})
102 | // }
103 | //
104 | // func TestNormalize(t *testing.T) {
105 | // 	Convey("When I #Normalize a string", t, func() {
106 | // 		result := Normalize("The Time Has Come")
107 | // 		So(result, ShouldEqual, "the-time-has-come")
108 | // 	})
109 | // }
110 | //
111 | // func TestCamel(t *testing.T) {
112 | // 	Convey("When I #Camel a string", t, func() {
113 | // 		result := Camel("hello world")
114 | // 		So(result, ShouldEqual, "HelloWorld")
115 | // 	})
116 | // }
117 | //
118 | // func TestCamelLower(t *testing.T) {
119 | // 	Convey("When I #CamelLower a string", t, func() {
120 | // 		result := CamelLower("hello world")
121 | // 		So(result, ShouldEqual, "helloWorld")
122 | // 	})
123 | // }
124 | //
125 | // func TestSnake(t *testing.T) {
126 | // 	Convey("When I #Snake a string", t, func() {
127 | // 		result := Snake("hello world.argle.bargle")
128 | // 		So(result, ShouldEqual, "hello_world_argle_bargle")
129 | // 	})
130 | // }
131 | 


--------------------------------------------------------------------------------
/template/template.go:
--------------------------------------------------------------------------------
  1 | // The MIT License (MIT)
  2 | //
  3 | // Copyright (c) 2014 Matt Ho
  4 | //
  5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | // of this software and associated documentation files (the "Software"), to deal
  7 | // in the Software without restriction, including without limitation the rights
  8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | // copies of the Software, and to permit persons to whom the Software is
 10 | // furnished to do so, subject to the following conditions:
 11 | //
 12 | // The above copyright notice and this permission notice shall be included in all
 13 | // copies or substantial portions of the Software.
 14 | //
 15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 | // SOFTWARE.
 22 | 
 23 | package template
 24 | 
 25 | import (
 26 | 	"bytes"
 27 | 	"fmt"
 28 | 	"regexp"
 29 | 	text_template "text/template"
 30 | )
 31 | 
 32 | var (
 33 | 	// $name__filter1__filter2$
 34 | 	shortFormat = regexp.MustCompile(`\$(([a-zA-Z0-9](_[a-zA-Z0-9]+)*)+(__[a-zA-Z0-9]+)*)\$`)
 35 | 
 36 | 	// $name;format="filter1,filter2"$
 37 | 	longFormat = regexp.MustCompile(`\$((\w+);format="([^"]+)")\$`)
 38 | )
 39 | 
 40 | const (
 41 | 	leftDelim  = "{\000{"
 42 | 	rightDelim = "}\000}"
 43 | )
 44 | 
 45 | // converts data on the other end of the reader to a golang template
 46 | func Parse(text []byte) (*text_template.Template, error) {
 47 | 	text = transform(text)
 48 | 
 49 | 	return text_template.New("template").Funcs(funcMap).Delims(leftDelim, rightDelim).Parse(string(text))
 50 | }
 51 | 
 52 | func Render(text []byte, data interface{}) ([]byte, error) {
 53 | 	t, err := Parse(text)
 54 | 	if err != nil {
 55 | 		return nil, err
 56 | 	}
 57 | 
 58 | 	buffer := bytes.NewBuffer([]byte{})
 59 | 	err = t.Execute(buffer, data)
 60 | 	if err != nil {
 61 | 		return nil, err
 62 | 	}
 63 | 
 64 | 	return buffer.Bytes(), nil
 65 | }
 66 | 
 67 | // transform templates in the short format to go templates e.g. name__filter1__filter2
 68 | func transformShort(text []byte) []byte {
 69 | 	results := text
 70 | 	matches := shortFormat.FindAllSubmatch(results, -1)
 71 | 	for _, match := range matches {
 72 | 		segments := bytes.Split(match[1], []byte("__"))
 73 | 		// macro := fmt.Sprintf("{{ .%s }}", bytes.Join(segments, []byte(" | ")))
 74 | 		macro := fmt.Sprintf(leftDelim+" .%s "+rightDelim, bytes.Join(segments, []byte(" | ")))
 75 | 		results = bytes.Replace(results, match[0], []byte(macro), -1)
 76 | 	}
 77 | 
 78 | 	return results
 79 | }
 80 | 
 81 | // transform templates in the long format to go templates e.g. name;filter="lower,snake"
 82 | func transformLong(text []byte) []byte {
 83 | 	results := text
 84 | 	matches := longFormat.FindAllSubmatch(results, -1)
 85 | 	for _, match := range matches {
 86 | 		field := match[2]
 87 | 		filters := match[3]
 88 | 
 89 | 		segments := [][]byte{field}
 90 | 		segments = append(segments, bytes.Split(filters, []byte(","))...)
 91 | 
 92 | 		// macro := fmt.Sprintf("{{ .%s }}", bytes.Join(segments, []byte(" | ")))
 93 | 		macro := fmt.Sprintf(leftDelim+" .%s "+rightDelim, bytes.Join(segments, []byte(" | ")))
 94 | 		results = bytes.Replace(results, match[0], []byte(macro), -1)
 95 | 	}
 96 | 
 97 | 	return results
 98 | }
 99 | 
100 | // helper to combine both short and long transforms
101 | func transform(text []byte) []byte {
102 | 	text = giter8ify(text)
103 | 	text = transformShort(text)
104 | 	text = transformLong(text)
105 | 	return text
106 | }
107 | 


--------------------------------------------------------------------------------
/template/template_test.go:
--------------------------------------------------------------------------------
  1 | // // The MIT License (MIT)
  2 | // //
  3 | // // Copyright (c) 2014 Matt Ho
  4 | // //
  5 | // // Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | // // of this software and associated documentation files (the "Software"), to deal
  7 | // // in the Software without restriction, including without limitation the rights
  8 | // // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | // // copies of the Software, and to permit persons to whom the Software is
 10 | // // furnished to do so, subject to the following conditions:
 11 | // //
 12 | // // The above copyright notice and this permission notice shall be included in all
 13 | // // copies or substantial portions of the Software.
 14 | // //
 15 | // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | // // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | // // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | // // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | // // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | // // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 21 | // // SOFTWARE.
 22 | //
 23 | package template
 24 | //
 25 | // import (
 26 | // 	"bytes"
 27 | // 	. "github.com/smartystreets/goconvey/convey"
 28 | // 	"testing"
 29 | // )
 30 | //
 31 | // func TestShortFormat(t *testing.T) {
 32 | // 	Convey("Given a short format template", t, func() {
 33 | // 		template := `before_$hello__world__argle$_after`
 34 | //
 35 | // 		Convey("When I find string matches with the shortFormat", func() {
 36 | // 			matches := shortFormat.FindAllStringSubmatch(template, -1)
 37 | //
 38 | // 			Convey("Then I expect the string interpolation to be found", func() {
 39 | // 				So(len(matches), ShouldEqual, 1)
 40 | // 				So(matches[0][0], ShouldEqual, `$hello__world__argle$`)
 41 | // 				So(matches[0][1], ShouldEqual, `hello__world__argle`)
 42 | // 			})
 43 | // 		})
 44 | //
 45 | // 		Convey("When I transform the template to a go template", func() {
 46 | // 			text := transformShort([]byte(template))
 47 | //
 48 | // 			Convey("And the content should be in go template format", func() {
 49 | // 				So(string(text), ShouldEqual, "before_{{ .hello | world | argle }}_after")
 50 | // 			})
 51 | // 		})
 52 | // 	})
 53 | // }
 54 | //
 55 | // func TestLongFormat(t *testing.T) {
 56 | // 	Convey("Given a long format template", t, func() {
 57 | // 		template := `before_$name;format="normalize,lower"$_after`
 58 | //
 59 | // 		Convey("When I find string matches with the longFormat", func() {
 60 | // 			matches := longFormat.FindAllStringSubmatch(template, -1)
 61 | //
 62 | // 			Convey("Then I expect the string interpolation to be found", func() {
 63 | // 				So(len(matches), ShouldEqual, 1)
 64 | // 				So(matches[0][0], ShouldEqual, `$name;format="normalize,lower"$`)
 65 | // 				So(matches[0][1], ShouldEqual, `name;format="normalize,lower"`)
 66 | // 				So(matches[0][2], ShouldEqual, `name`)
 67 | // 				So(matches[0][3], ShouldEqual, `normalize,lower`)
 68 | // 			})
 69 | // 		})
 70 | //
 71 | // 		Convey("When I transform the template to a go template", func() {
 72 | // 			text := transformLong([]byte(template))
 73 | //
 74 | // 			Convey("And the content should be in go template format", func() {
 75 | // 				So(string(text), ShouldEqual, "before_{{ .name | normalize | lower }}_after")
 76 | // 			})
 77 | // 		})
 78 | // 	})
 79 | // }
 80 | //
 81 | // func TestParse(t *testing.T) {
 82 | // 	Convey("Given the text of a template", t, func() {
 83 | // 		text := []byte(`hello $name;format="lower"$`)
 84 | //
 85 | // 		Convey("When I Parse the template", func() {
 86 | // 			template, err := Parse(text)
 87 | //
 88 | // 			Convey("Then I expect no errors", func() {
 89 | // 				So(err, ShouldBeNil)
 90 | // 			})
 91 | //
 92 | // 			Convey("And I expect a valid template back", func() {
 93 | // 				So(template, ShouldNotBeNil)
 94 | // 			})
 95 | //
 96 | // 			Convey("And I expect the executed template to return the correct value", func() {
 97 | // 				buffer := bytes.NewBuffer([]byte{})
 98 | // 				template.Execute(buffer, map[string]string{"name": "world"})
 99 | // 				So(buffer.String(), ShouldEqual, "hello world")
100 | // 			})
101 | // 		})
102 | // 	})
103 | //
104 | // 	Convey("Given an invalid template", t, func() {
105 | // 		text := []byte("{{ ")
106 | //
107 | // 		Convey("When I #Parse the template", func() {
108 | // 			_, err := Parse(text)
109 | //
110 | // 			Convey("Then I expect an error to be returned", func() {
111 | // 				So(err, ShouldNotBeNil)
112 | // 			})
113 | // 		})
114 | // 	})
115 | // }
116 | //
117 | // func TestRender(t *testing.T) {
118 | // 	Convey("Given a text template that uses both the long and short format", t, func() {
119 | // 		text := []byte(`hello $name;format="lower"$; HELLO $name__upper$`)
120 | //
121 | // 		Convey(`When I call #Render`, func() {
122 | // 			value, err := Render(text, map[string]string{"name": "WoRlD"})
123 | //
124 | // 			Convey("Then I expect no errors", func() {
125 | // 				So(err, ShouldBeNil)
126 | // 			})
127 | //
128 | // 			Convey("And I expect our interpolated string back", func() {
129 | // 				So(string(value), ShouldEqual, "hello world; HELLO WORLD")
130 | // 			})
131 | // 		})
132 | // 	})
133 | // }
134 | 


--------------------------------------------------------------------------------