simple-templater 0.0.1

data/CHANGELOG

@@ -0,0 +1,10 @@
+= Version 0.0.1
+  * Imported from Rango
+  * bin/simple-templater can generate a project or a stub
+  * it can find all gems with simple-templater.scope file in the root
+  * it has hooks running before & after templater
+  * it knows how to work with diff stubs
+  * it can have variables in file names of stub files
+  * it can have collections in file names of stub files
+  * it use Erubis for processing templates (all files ending with .rbt)
+  * it has context and hooks for interaction with user (ARGV/STDIN)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Šťastný aka Botanicus
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,136 @@
+h1. About
+
+"SimpleTemplater":http://github.com/botanicus/simple-templater is dead-simple solution for creating generators. It strongly uses convention over configuration, so you don't have to write loads of code to generate one stupid plain text README.
+
+h1. Usage
+
+h2. Available Generators
+
+Even if SimpleTemplater is more API for writting generators, it has some custom included.
+
+h3. Stub Generator
+
+If you want to create your new generator, this is what you are looking for. Just run @simple-templater create stub my_generator@ and that's it!
+
+* @--flat@ | @--no-flat@ (default: @--no-flat@)
+* @--full@ | @--no-full@ (default: @--full@)
+* @--setup-hook@ | @--no-setup-hook@ (default: @--setup-hook@)
+* @--postprocess-hook@ | @--no-postprocess-hook@ (default: @--postprocess-hook@)
+
+h3. Project Generator
+
+Project generator can generate new Ruby project.
+
+* @--full-name="Jakub Stastny"@
+* @--git-repository@ if you want to create new Git repository and do the initial commit (default: will ask you)
+* @--github-user=botanicus@ (default: ENV["USER"])
+* @--github-repository=simple-templater@ (default: same as name of the new project)
+
+h2. API
+
+You would probably want to use simple templater for your own generators, here is how:
+
+<pre>
+require "simple-templater"
+
+templater = SimpleTemplater.new(:rango, SimpleTemplater.logger)
+if defined?(Gem) # try to find generators installed as gems
+  templater.discovery!
+else
+  SimpleTemplater.logger.warn "Running without RubyGems which means SimpleTemplater won't be able to find generators distributed as a Gems."
+  # register generators just for rango
+  load File.join(File.dirname(__FILE__), "..", "simple-templater.scope")
+end
+templater.run(ARGV.shift) # run generator from ARGV, for example "project"
+</pre>
+
+h2. File Hierarchy
+
+- @stubs/#{generator_name}/setup.rb@
+- @stubs/#{generator_name}/postprocess.rb@
+- @stubs/#{generator_name}/content@
+
+h2. Templates
+
+Every file in @stubs/#{generator_name}/content@ will be proceed:
+
+- *Files which doesn't require ERB processing* are simply copy from @stubs/#{generator_name}/content/file.txt@ to @#{project_name}/file.txt@
+- *Files with .rbt extension and ERB tags inside* will be proceed by Erubis and the result without @.rbt@ extension will be written to @stubs/#{generator_name}/content/app/models/post.rb@ to @#{project_name}/app/models/post.rb@.
+- If you want to generate file with @rbt@ extension, just put append another .rbt: @file.txt.rbt.rbt@ => @#{project_name}/file.txt.rbt@. The template will be proceed by Erubis. If you want to get @<%= %>@ on the output, just use @<%%= %>@.
+
+h2. Hooks
+
+Each item in ARGV starting with @--@ is processed by a hook. Hooks can be distributed
+
+<pre>
+# default arguments for hook
+hook do |generator, context|
+  context.reverse_merge!(git_repository: true)
+end
+</pre>
+
+h3. Preprocessing
+
+h4. ARGV Parsing
+
+- First argument will typically be name of the generator (unless you provide just one generator and the name is hardcoded)
+- @--orm@ to @{orm: true}@
+- @--no-orm@ to @{orm: false}@
+- @--orm=datamapper@ to @{orm: "datamapper"}@
+- @--models=post,comment@ to @{models: ["post", "comment"]}@
+- @options = ARGV.parse!@
+- For testing you may use the @parse!@ method after @YourArray.extend(ArgvParsingMixin)@
+
+h4. User Interaction
+
+- Do you want to
+- @--github@ or @--no-github@
+
+@your-gen project --models=post,comment --controller=posts --orm=datamapper@
+
+- the script don't have to be Ruby, but it will be easier for you since SimpleTemplater provides some basic ARGV parsing for you
+- the script have to be executable
+
+h2. Postprocessing
+
+h3. Examples
+
+- initialize Git repository
+- create Git repository on GitHub and push
+
+h1. Custom Generators
+
+Each user can create its own generators and put them to @~/.#{project_name}/stubs/#{generator_name}@. For example project generators for Rango should be placed to @~/.rango/stubs/project@
+
+h2. Generators Registration in Plugins
+
+You often may want to
+
+In Rango:
+
+<pre>
+SimpleTemplater::Discovery.discover!(:rango)
+</pre>
+
+<pre>
+SimpleTemplater.register(:rango) # register relative path to stubs/*
+</pre>
+
+or
+
+<pre>
+SimpleTemplater.register(:rango) do
+  # do some initialization
+end
+</pre>
+
+h2. Diff Generators
+
+- rewrite some default files
+- hooks
+
+h1. Links
+
+- "Source Code":http://github.com/botanicus/simple-templater
+- "RunCodeRun":http://runcoderun.com/botanicus/simple-templater
+- "API Documentation":http://rdoc.info/projects/botanicus/simple-templater

data/Rakefile

@@ -0,0 +1,79 @@
+#!/usr/bin/env rake1.9
+# encoding: utf-8
+
+# http://support.runcoderun.com/faqs/builds/how-do-i-run-rake-with-trace-enabled
+Rake.application.options.trace = true
+
+task :setup => ["submodules:init"]
+
+namespace :submodules do
+  desc "Init submodules"
+  task :init do
+    sh "git submodule init"
+  end
+
+  desc "Update submodules"
+  task :update do
+    Dir["vendor/*"].each do |path|
+      if File.directory?(path) && File.directory?(File.join(path, ".git"))
+        Dir.chdir(path) do
+          puts "=> #{path}"
+          puts %x[git reset --hard]
+          puts %x[git fetch]
+          puts %x[git reset origin/master --hard]
+          puts
+        end
+      end
+    end
+  end
+end
+
+task :gem do
+  sh "gem build simple-templater.gemspec"
+end
+
+namespace :gem do
+  task :prerelease do
+    require_relative "lib/simple-templater"
+    gemspec = Dir["*.gemspec"].first
+    content = File.read(gemspec)
+    prename = "#{gemspec.split(".").first}.pre.gemspec"
+    version = SimpleTemplater::VERSION.sub(/^(\d+)\.(\d+)\.\d+$/) { "#$1.#{$1.to_i + 1}" }
+    File.open(prename, "w") do |file|
+      file.puts(content.gsub(/(\w+::VERSION)/, "'#{version}.pre'"))
+    end
+    sh "gem build #{prename}"
+    rm prename
+  end
+end
+
+desc "Release new version of simple-templater"
+task release: ["release:tag", "release:gemcutter"]
+
+namespace :release do
+  desc "Create Git tag"
+  task :tag do
+    require_relative "lib/simple-templater"
+    puts "Creating new git tag #{SimpleTemplater::VERSION} and pushing it online ..."
+    sh "git tag -a -m 'Version #{SimpleTemplater::VERSION}' #{SimpleTemplater::VERSION}"
+    sh "git push --tags"
+    puts "Tag #{SimpleTemplater::VERSION} was created and pushed to GitHub."
+  end
+
+  desc "Push gem to Gemcutter"
+  task :gemcutter do
+    puts "Pushing to Gemcutter ..."
+    sh "gem push #{Dir["*.gem"].last}"
+  end
+
+  desc "Create and push prerelease gem"
+  task :pre => ["gem:prerelease", :gemcutter]
+end
+
+desc "Run specs"
+task :default => :setup do
+  rubylib = (ENV["RUBYLIB"] || String.new).split(":")
+  libdirs = Dir["vendor/*/lib"]
+  ENV["RUBYLIB"] = (libdirs + rubylib).join(":")
+  exec "./script/spec --options spec/spec.opts spec"
+end

data/TODO.txt

@@ -0,0 +1,15 @@
+=== Version 0.2 ===
+- javascripts/{javascript}.js for collections (instead of %javascript%)
+- hooks: description
+- better CLI interface, so project can just run SimpleTemplater::CLI.exec(scope, ARGV)
+- improve project generator (see my other projects)
+- better syntax for simple-templater.scope
+
+=== Version 0.3 ===
+- bin/simple-templater
+- Logger from Rango (-> RubyExts)
+
+=== Version 0.4 ===
+- 100% specs coverage & refactoring
+- YARD Code Documentation
+- discoverers: Rip, plain (for classic unix systems, so it will just look for generators in /usr/share or wherevers)

data/bin/simple-templater

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby1.9
+# encoding: utf-8
+
+# --list (scope): list all generators available for given scope or just list all generators
+# -i | --interactive run IRB with loaded simple templater
+# --scopes: list all available scopes
+# --help
+
+# simple-templater [scope] [generator] [options] [arguments]
+# simple-templater rango project my_blog --orm=datamapper
+
+base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+libdir = File.expand_path(File.join(File.dirname(base), "..", "lib"))
+
+vendor = File.join(File.dirname(__FILE__), "..", "vendor")
+if File.directory?(vendor)
+  Dir["#{vendor}/*"].each do |path|
+    if File.directory?(path) && Dir["#{path}/*"].empty?
+      warn "Dependency #{File.basename(path)} in vendor seems to be empty. Run git submodule init && git submodule update to checkout it."
+    elsif File.directory?(path) && File.directory?(File.join(path, "lib"))
+      $:.unshift(File.join(path, "lib"))
+    end
+  end
+end
+
+# because of system installation, there is bin/../lib, but not bin/../lib/rango
+if File.directory?(File.join(libdir, "simple-templater"))
+  # NOTE: don't test if libdir is already in $:, just put it there,
+  # otherwise you might get errors because of you are loading bad simple-templater
+  $:.unshift(libdir)
+end
+
+require "simple-templater"
+
+# === Helpers === #
+# TODO: Generators.each { |generator| puts generator.help }
+def usage
+<<-HELP
+=== Usage ===
+rango create project mycoolproject    Generate new site
+rango create app mycoolapp            Generate new application
+HELP
+end
+
+begin
+  ARGV.shift # create
+  generator_name = ARGV.shift
+  templater = SimpleTemplater.new(:simple_templater)
+  # This enables you to create custom generators for Rango
+  load "simple-templater.scope" # neccesary if we run rango locally and not from RubyGems
+  templater.discover!
+  generator_set = templater.find(generator_name)
+  if generator_set.nil?
+    abort "Generator #{generator_name} doesn't exist. Available generators are: #{templater.generators.map { |set| set.name }.inspect}"
+  else
+    begin
+      generator_set.run(ARGV)
+    rescue SimpleTemplater::TargetAlreadyExist => exception
+      abort exception.message
+    rescue Interrupt
+      exit
+    rescue Exception => exception
+      abort "Exception #{exception.inspect} occured during running generator #{generator_set.inspect}\n#{exception.backtrace.join("\n")}"
+    end
+  end
+end

data/deps.rip

@@ -0,0 +1,7 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+git://github.com/botanicus/cli.git
+git://github.com/botanicus/rubyexts.git
+git://github.com/genki/erubis.git

data/lib/simple-templater/argv_parsing.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+class SimpleTemplater
+  module ArgvParsingMixin
+    def parse!
+      self.inject(Hash.new) do |options, argument|
+        case argument
+        when /^--no-([^=]+)$/ # --no-git-repository
+          options[$1.gsub("-", "_").to_sym] = false
+        when /^--([^=]+)$/    # --git-repository
+          options[$1.gsub("-", "_").to_sym] = true
+        when /^--([^=]+)=([^,]+)$/ # --controller=post
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.dup
+        when /^--([^=]+)=(.+)$/    # --controllers=posts,comments
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.split(",")
+        else
+          raise "Parsing failed on: #{argument}"
+        end
+        options
+      end
+    end
+  end
+end
+
+ARGV.extend(SimpleTemplater::ArgvParsingMixin)

data/lib/simple-templater/builder.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require "erubis"
+require "fileutils"
+require "tempfile"
+require "find"
+require "simple-templater/helpers"
+
+module FileUtils
+  def self.cp_f(source, target)
+    sh "cp -f '#{source}' '#{target}'"
+    # self.rm target
+    # self.cp source, target
+  end
+end
+
+# @since 0.0.3
+# @example
+#   SimpleTemplater::Builder.create("my_generator_dir", user: "botanicus", constant: -> { |argv| argv.first.camel_case })
+class SimpleTemplater
+  class Builder
+    def self.create(*args)
+      templater = self.new(*args)
+      SimpleTemplater.logger.debug("Context: #{templater.context.inspect}")
+      templater.create
+    end
+
+    attr_accessor :context
+    def initialize(content_dir, context = Hash.new)
+      @content_dir, @context = content_dir, context
+    end
+
+    def create
+      Find.find(@content_dir) do |template|
+        file = self.expand_path(template)
+        next if template == @content_dir
+        proceed(template, file)
+      end
+    end
+
+    protected
+    # %name%_controller.rb => application_controller.rb
+    def expand_path(file)
+      self.location(file).sub(/\.rbt$/, "")
+    end
+
+    def location(file)
+      file.sub(%r[^#{Regexp::quote(@content_dir)}/?], "")
+    end
+
+    # TODO: %a%/%b% etc, now it can handle just one %var%
+    def proceed(template, file)
+      # OK, this is a bit tricky, but it works
+      # == TEMPLATE ==   | == CONTEXT ==             | == OUTPUT ==
+      # config/%user%.rb | {user: "botanicus"}       | config/botanicus.rb
+      # %model%.rb       | {models: ["tag", "post"]} | tag.rb, post.rb
+      if template.match(/%(\w+)%/)
+        singular, plural = $1.to_sym, "#{$1}s".to_sym # TODO: use inflector
+        if self.context.has_key?(singular)
+          target = file.sub(/%(\w+)%/, self.context[singular])
+          proceed_file(template, target)
+        elsif self.context.has_key?(plural)
+          variables = self.context[plural] || Array.new
+          variables.each do |variable|
+            target = file.sub(/%(\w+)%/, variable)
+            proceed_file(template, target, {singular => variable})
+          end
+        else
+          raise "Context #{self.context.inspect} doesn't have key #{singular} or #{plural}"
+        end
+      else
+        proceed_file(template, file)
+      end
+    end
+
+    def proceed_file(template, file, local_context = Hash.new)
+      SimpleTemplater.logger.debug("Local context: #{local_context.inspect}") unless local_context.empty?
+      FileUtils.mkdir_p(File.dirname(file))
+
+      if File.directory?(template)
+        FileUtils.rm_rf(file) # directory include its content
+        FileUtils.mkdir(file)
+      end
+
+      if template.end_with?(".rbt")
+        if File.exist?(file)
+          SimpleTemplater.logger.debug("[RETEMPLATE] #{file} (from #{template})")
+        else
+          SimpleTemplater.logger.debug("[TEMPLATE] #{file} (from #{template})")
+        end
+        File.open(file, "w") do |file|
+          eruby = Erubis::Eruby.new(File.read(template))
+          context = Erubis::Context.new(@context.merge(local_context))
+          context.extend(SimpleTemplater::Helpers)
+          begin
+            output = eruby.evaluate(context)
+          rescue Exception => exception
+            SimpleTemplater.logger.error("Exception occured in template #{template}: #{exception.message}")
+          end
+          file.print(output)
+        end
+      else # just copy
+        if File.directory?(file)
+          # do nothing
+          # it shouldn't get here never, we have File.directory? above
+        elsif File.file?(file)
+          SimpleTemplater.logger.debug("[RECOPY] #{file} (from #{template})")
+          FileUtils.cp_f(template, file)
+        else
+          SimpleTemplater.logger.debug("[COPY] #{file} (from #{template})")
+          FileUtils.cp(template, file)
+        end
+      end
+
+      copy_permissions template, file
+    end
+
+    def copy_permissions(template, file) # TODO: reimplement, this is crap
+      File.chmod(0755, file) if File.executable?(template)
+    end
+  end
+
+  class FlatBuilder < Builder
+    attr_reader :source, :target
+    def initialize(source, target, context = Hash.new)
+      @source, @target, @context = source, target, context
+      @content_dir = File.expand_path(File.join(source, ".."))
+    end
+
+    def create
+      proceed(self.source, self.target)
+    end
+  end
+end

data/lib/simple-templater/discoverer.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class SimpleTemplater
+  class Discoverer
+    def self.detect
+      # TODO: coming in version 0.2
+      require "simple-templater/discoverers/gems"
+      SimpleTemplater::RubyGems
+    end
+
+    attr_reader :scope
+    def initialize(scope)
+      @scope = scope
+    end
+
+    def run
+      raise NotImplementedError
+    end
+  end
+end

data/lib/simple-templater/discoverers/gems.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+# Mostly stolen from Templater http://github.com/jnicklas/templater
+
+# This provides a hook system which programs that use Templater can use to discover generators
+# installed through gems. This requires two separate things, the Templater-using progrma will
+# have to call the #discover! method giving a scope, like this:
+#
+#     Templater::Discovery.discover!("name-of-scope")
+#
+# Where "name-of-scope" should be a string that uniquely identifies your program. Any gem wishing
+# to then add a generator, that is automatically picked up, will then need to add a simple-templater.scope
+# file at the root of the project (don't forget to add it to the gem's manifest of files).
+#
+#     - lib /
+#     - spec /
+#     - Rakefile
+#     - simple-templater.scope
+#
+# This file should look something like this:
+#
+#     SimpleTemplater.scope(:rango) do
+#       root = File.dirname(__FILE__)
+#       Dir["#{root}/stubs/*"].each do |stub_dir|
+#         if File.directory?(stub_dir)
+#           SimpleTemplater.register(:rango, stub_dir)
+#         end
+#       end
+#     end
+#
+# Multiple scopes can be added to the same simple-templater.scope file for use with different generator
+# programs.
+
+class SimpleTemplater
+  class RubyGems < Discoverer
+    # Searches installed gems for simple-templater.scope files and loads all code blocks in them that match
+    # the given scope.
+    #
+    # === Parameters
+    # scope<String>:: The name of the scope to search for
+    def run
+      generator_files.each { |file| load file }
+      if SimpleTemplater.scopes[self.scope]
+        SimpleTemplater.scopes[self.scope].each do |block|
+          begin
+            block.call
+          rescue Exception => exception
+            warn "[Scope #{self.scope}] Exception #{exception.class}: #{exception} occured in scope file #{block.inspect}\n#{exception.backtrace.join("\n")}"
+          end
+        end
+      end
+    end
+
+    def find_latest_gem_paths
+      require "rubygems" unless defined?(Gem)
+      # Minigems provides a simpler (and much faster) method for finding the
+      # latest gems.
+      if Gem.respond_to?(:latest_gem_paths)
+        Gem.latest_gem_paths
+      else
+        gems = Gem.cache.inject(Hash.new) do |latest_gems, cache|
+          name, gem = cache
+          currently_latest = latest_gems[gem.name]
+          latest_gems[gem.name] = gem if currently_latest.nil? or gem.version > currently_latest.version
+          latest_gems
+        end
+        gems.values.map { |gem| gem.full_gem_path }
+      end
+    end
+
+    def generator_files
+      find_latest_gem_paths.inject(Array.new) do |files, gem_path|
+        path = ::File.join(gem_path, "simple-templater.scope")
+        files << path if ::File.file?(path)
+        files
+      end
+    end
+  end
+end

data/lib/simple-templater/discoverers/plain.rb

@@ -0,0 +1 @@
+# for systems without any package manager

data/lib/simple-templater/discoverers/rip.rb

@@ -0,0 +1 @@
+# TODO: coming in version 0.2

data/lib/simple-templater/dsl.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require "fileutils"
+require "cli" # yes? etc
+
+class SimpleTemplater
+  class DSL
+    include FileUtils
+    attr_reader :generator, :context
+    def initialize(generator)
+      @generator = generator
+      @context   = generator.context
+    end
+
+    def make_executable(path)
+      sh "chmod +x '#{path}'"
+    end
+    
+    def file(name, &block)
+      File.open(name, "w", &block)
+    end
+    
+    def hook(&block)
+      block.call(self.generator, self.context)
+    end
+  end
+end