GN(1)
NAME
gn -- The simplest template generator.
SYNOPSIS
gn <plan>
gn -i <plan-url>
gn -h
DESCRIPTION
<plan>
Opens the blueprints with the default editor, and once saved
it expands the templates.
-i <plan-url>
Installs the given plan from a git repository. It clones the
repository to ~/.gn/<plan>.
-h
Display this help message.
EXAMPLE PLAN
A plan is a directory in ~/.gn/<plan>, with the following
structure:
~/.gn/<plan>/plan.rb
~/.gn/<plan>/plan/<template>.mote
For example, consider a plan for generating a gemspec file.
~/.gn/gemspec/plan.rb
~/.gn/gemspec/plan/gemspec.mote
The plan definition `plan.rb` has this format:
module Plan
class GemSpec
def name
"foo"
end
def version
"0.0.1"
end
def description
"Description of my gem"
end
def authors
["My Name"]
end
def email
["[email protected]"]
end
def homepage
"http://example.com/"
end
def license
"MIT"
end
def destination
"#{name}.gemspec"
end
end
end
The only mandatory method is `destination`. Everything else is
optional and is based on how the template is designed.
Templates are rendered using mote (http://soveran.github.com/mote),
the minimalist template engine. Variable interpolation is
done by using the {{variable}} syntax, as shown in the example
below. Variable names are extracted from the plan context, in this
case an instance of `Plan::GemSpec`.
# encoding: utf-8
Gem::Specification.new do |s|
s.name = "{{name}}"
s.version = "{{version}}"
s.summary = "{{description}}"
s.description = "{{description}}"
s.authors = {{authors.inspect}}
s.email = {{email.inspect}}
s.homepage = "{{homepage}}"
s.files = []
s.license = "{{license}}"
# s.executables.push(<executable>)
# s.add_dependency <dependency>, <version>
end
Refer to de advanced example for information about how to
generate different files and directory structures.
ADVANCED EXAMPLE
It is possible to use gn to generate several files and even
complex directory structures. Consider this plan definition:
$ find .gn/foo
.gn/foo//plan.rb
.gn/foo//plan/foo.mote
.gn/foo//plan/bar/baz.mote
$ cat plan.rb
module Plan
class Foo
def destination
"foo.rb"
end
end
module Bar
class Bar
def destination
"bar/baz.rb"
end
end
end
end
EDITING A PLAN
When using a template, gn gives you the ability to edit the plan
before running it. Only the templates that correspond to classes
defined in the Plan module get expanded and written. It means
that if you want to create only the file `foo.rb` in the example
above, all you have to do is delete the Bar module from the plan
definition.
INSTALLATION
$ gem install gn
HISTORY
In software development, there's usually the need to generate
code or directory structures, and many tools have this feature
built in. The idea with gn is to provide a small and simple tool
that generalizes the task of template expansion in a way that's
easy to understand, yet powerful and flexible.