gn 0.1.0 → 0.1.1

data/README

@@ -0,0 +1,143 @@
+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
+                ["my_name@example.com"]
+              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.

data/bin/gn

@@ -2,21 +2,42 @@
 
 require_relative "../lib/gn"
 
-name = ARGV.first.to_s.strip
+require "clap"
+require "fileutils"
 
-if name.empty? || name == "-h" || name == "--help"
+module CLI
+  README  = File.expand_path("../README", File.dirname(__FILE__))
+  GN_HOME = File.join(ENV["HOME"], ".gn")
 
-  puts <<-USAGE
-  Usage: gn <name>
+  # Display the README message and exit.
+  def self.help
+    exec "${PAGER:-less} #{README}"
+  end
+
+  def self.install(template)
+
+    # Create directory for templates if it doesn't exist.
+    FileUtils.mkdir_p(GN_HOME)
+
+    # Clone the template repository.
+    Dir.chdir(GN_HOME) do
+      exec "git clone %s" % template
+    end
+  end
+end
 
-  Run the <name> generator found in ~/.gn/<name>.
+# Display the README if there are no arguments.
+CLI.help if ARGV.empty?
 
-  See http://lucasefe.github.com/gn for more information.
-  USAGE
+rest = Clap.run ARGV,
+  "-h"      => CLI.method(:help),
+  "--help"  => CLI.method(:help)
 
-else
-  require "fileutils"
+rest = Clap.run rest,
+  "-i"        => CLI.method(:install),
+  "--install" => CLI.method(:install)
 
+rest.each do |name|
   gn = Gn.new(name)
 
   # Load edited plan.

data/lib/gn.rb

@@ -39,7 +39,7 @@ class Gn
   end
 
   def load!
-    file = Tempfile.new(PLAN_FILE)
+    file = Tempfile.new([PLAN_FILE, ".rb"])
     file.write(File.read(path(PLAN_FILE)))
     file.close
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gn
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-22 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mote
@@ -29,6 +29,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: clap
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple Generator for the masses
 email:
 - lucasefe@gmail.com
@@ -41,7 +57,7 @@ files:
 - lib/gn/dsl.rb
 - bin/gn
 - LICENSE
-- Readme.md
+- README
 homepage: http://lucasefe.github.com/gn
 licenses:
 - MIT

data/Readme.md

@@ -1,88 +0,0 @@
-# gn
-
-## Description
-
-gn is the simplest file/folder/structure/whatever generator you could
-ever find.
-
-## Usage
-
-Say you want to generate always a typical `README` file, like this
-one, you should do the following:
-
-Create a folder `~/.gn/readme` and add a `plan.rb` file with the
-following content:
-
-```ruby
-module Plan
-  class README
-    def name
-      "CHANGEME"
-    end
-
-    def author
-      "Your Name"
-    end
-
-    def destination
-      "README"
-    end
-  end
-end
-```
-
-The only mandatory method is `destination`. Everything else is
-optional and is based on how the template is designed.
-
-Create a `~/.gn/readme/plan` folder and add the template for your
-README file:
-
-```
-mkdir ~/.gn/readme/plan
-touch ~/.gn/readme/plan/readme.mote
-```
-
-For example, add the following to the template:
-
-```markdown
-# {{name}}
-
-Copyright (c) 2012 {{author}}
-```
-
-Templates are rendered using [`mote`](http://soveran.github.com/mote),
-the minimalist template engine. In `mote`, variable interpolation is
-done by using the `{{variable}}` syntax, as shown in the example
-above. Variable names are extracted from the current context, in this
-case an instance of `Plan::README`.
-
-Then run the generator like this:
-
-```
-gn readme
-```
-
-Now your default `$EDITOR` will pop open with a copy of your `plan.rb`
-file, ready to be updated if necessary. Note that the original
-`plan.rb` file won't be modified.
-
-Close your editor and you are done! Your `gn` generated `README` file
-will be placed in your current directory.
-
-## Other usages
-
-You can use gn to generate different things. In our case, we
-designed it so we could generate basic crud/scaffolds for
-[Cuba](http://soveran.github.com/cuba), but you can use it for
-anything you want.
-
-See the folder named examples for some ideas.
-
-## Installation
-
-```
-gem install gn
-```
-
-Given that `gn` is still in development process, you should add
-`--pre` to your `gem install`.