gem-new 0.1.0

data/data/gem-new/default/meta.yaml

@@ -0,0 +1,3 @@
+---
+version:  1
+includes: []

data/data/gem-new/default/skeleton/GEM_NAME.gemspec.erb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name                      = <%= gem_name.inspect %>
+  s.version                   = <%= version.to_s.inspect %>
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1")
+  s.authors                   = <%= author.inspect %>
+  s.date                      = <%= date.inspect %>
+  s.description               = <<-DESCRIPTION.gsub(/^    /, '').chomp
+<%= description && description.gsub(/^/,'    ') %>
+  DESCRIPTION
+  s.summary                   = <<-SUMMARY.gsub(/^    /, '').chomp
+<%= summary && summary.gsub(/^/,'    ') %>
+  SUMMARY
+  s.email                     = <%= email.inspect %>
+  s.files                     =
+    Dir['bin/**/*'] +
+    Dir['lib/**/*'] +
+    Dir['rake/**/*'] +
+    Dir['test/**/*'] +
+    %w[
+      <%= "#{gem_name}.gemspec" %>
+      Rakefile
+      README.markdown
+    ]
+  s.require_paths             = %w[lib]
+  s.rubygems_version          = "1.3.1"
+  s.specification_version     = 3
+end

data/data/gem-new/default/skeleton/README.markdown.literal

@@ -0,0 +1,21 @@
+README
+======
+
+
+Summary
+-------
+<%= summary %>
+
+
+Installation
+------------
+`gem install <%= gem_name %>`
+
+
+Usage
+-----
+
+
+Description
+-----------
+<%= description %>

data/data/gem-new/default/skeleton/README_DIRECTORIES

@@ -0,0 +1,9 @@
+This readme informs you about the purpose of the directories
+
+PROJECT/bin:            Executable files
+PROJECT/documentation:  Prosa documentation of your project
+PROJECT/development:    Ideas and other things relevant for developing
+PROJECT/lib:            Your ruby library files
+PROJECT/rake/lib:       Libraries that are not part of your library, but used by your rake tasks
+PROJECT/rake/tasks:     Your rake tasks, using either .rb, .task or .rake as suffix
+PROJECT/test:           The tests for your library

data/data/gem-new/default/skeleton/Rakefile

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.expand_path('../rake/lib', __FILE__))
+Dir.glob(File.expand_path('../rake/tasks/**/*.{rake,task,rb}', __FILE__)) do |task_file|
+  begin
+    require task_file
+  rescue LoadError => e
+    warn "Failed to load task file #{task_file}"
+    warn "  #{e.class} #{e.message}"
+    warn "  #{e.backtrace.first}"
+  end
+end

data/data/gem-new/default/skeleton/lib/REQUIRE_NAME.rb.erb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name                      = "gem-new"
+  s.version                   = "0.1.0"
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1")
+  s.authors                   = ["Stefan Rusterholz"]
+  s.date                      = "2011-06-10"
+  s.default_executable        = "baretest"
+  s.description               = <<-DESCRIPTION.chomp
+    Gem-new is a gem command plugin that allows you to easily create a new gem.
+  DESCRIPTION
+  s.summary                   = <<-SUMMARY.chomp
+    Create new gems easily
+  SUMMARY
+  s.email                     = "stefan.rusterholz@gmail.com"
+  s.files                     = %w[
+    lib/rubygems_plugin.rb
+  ]
+  s.homepage                  = "http://github.com/apeiros/gem-new"
+  s.require_paths             = %w[lib]
+  s.rubygems_version          = "1.3.1"
+  s.specification_version     = 3
+end

data/data/gem-new/default/skeleton/lib/REQUIRE_NAME/version.rb.erb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'gem/version'
+
+module <%= namespace %>
+  Version = Gem::Version.new(<%= version.to_s.inspect %>)
+end

data/data/gem-new/gem-new-template/meta.yaml

@@ -0,0 +1,3 @@
+---
+version:  1
+includes: []

data/data/gem-new/gem-new-template/skeleton/data/GEM_NAME/your_template_name/meta.yaml

@@ -0,0 +1,3 @@
+---
+version:  1
+includes: []

data/lib/gem/commands/new_command.rb

@@ -0,0 +1,285 @@
+require 'rubygems/command'
+require 'gem/commands/new_command/configuration'
+require 'gem/commands/new_command/skeleton'
+require 'gem/commands/new_command/version'
+require 'fileutils'
+require 'open3'
+
+
+
+class Gem::Commands::NewCommand < Gem::Command
+  if Gem::Specification.respond_to?(:find_all) then
+    plugin_gems = Gem::Specification.find_all { |spec| spec.name =~ /^gem-new/ }
+  else
+    plugin_gems = Gem::SourceIndex.from_installed_gems.find_name(/^gem-new-/)
+  end
+
+  ConfigVersion       = 2
+  ConfigPath          = File.join(Gem.user_home, '.gem', 'new', 'config')
+  UserTemplatesDir    = [:user, nil, File.join(Gem.user_home, '.gem', 'new', 'templates')]
+  BundledTemplatesDir = [:bundled, nil, Gem.datadir('gem-new')]
+  PluginTemplatesDirs = plugin_gems.map { |spec|
+    spec.name
+  }.sort.map { |name|
+    gem name # load the gem, otherwise Gem.datadir is nil
+    [:gem, name, Gem.datadir(name)]
+  }
+  TemplateDirs        = [UserTemplatesDir] + PluginTemplatesDirs + [BundledTemplatesDir]
+
+  def initialize
+    super 'new', "Create a new gem"
+    add_option('-l', '--list-templates', 'Show a list of all templates') do |value, opts|
+      opts[:list_templates] = value
+    end
+    add_option('-t', '--template TEMPLATE', 'Use TEMPLATE instead of the default template') do |value, opts|
+      opts[:template] = value
+    end
+    add_option('--variables', 'Show all available variables') do |value, opts|
+      opts[:variables] = value
+    end
+  end
+
+  def execute
+    if File.exist?(ConfigPath) then
+      if Configuration.new(ConfigPath).config_version < ConfigVersion then
+        FileUtils.mv(ConfigPath, "#{ConfigPath}.bak")
+        generate_default_config
+        puts "Your configuration has been moved to #{ConfigPath}.bak and an updated configuration has been created"
+        exit if prompt "Abort now in order to inspect the configuration (recommended)?"
+      end
+    else
+      generate_default_config
+      puts "A new configuration was generated in #{ConfigPath}"
+      exit if prompt "Abort now in order to inspect the configuration (recommended)?"
+    end
+
+    if options[:list_templates] then
+      list_templates
+    else
+      generate_gem
+    end
+  rescue
+    puts "#{$!.class} #{$!.message}", *$!.backtrace.first(5)
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME          The name of the gem to generate"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  def defaults_str # :nodoc:
+    ""
+  end
+  
+  def description # :nodoc:
+    <<-DESCRIPTION.gsub(/^      /,'').chomp
+      Creates the basic directories and files of a new gem for you.
+      
+      TEMPLATES
+      You can provide custom templates in #{UserTemplatesDir}
+      To create a template named 'my_template', you'd create the following structure:
+      * #{UserTemplatesDir}/
+        * my_template/
+          * meta.yaml
+          * skeleton/
+      Within the 'skeleton' directory you place the files and directories for your skeleton.
+      Use `#{program_name} GEMNAME --variables` to see what variables are available for paths
+      and template-files.
+
+      CONFIGURATION
+      You can configure a couple of settings in #{ConfigPath}
+    DESCRIPTION
+    #'
+  end
+
+private
+  def templates
+    #Dir[template_glob].map { |path| File.basename(path) }.uniq.sort
+    seen = {}
+    list = []
+    TemplateDirs.each do |source_type, source_name, dir|
+      Dir.glob(File.join(dir, '*')) do |path|
+        name = File.basename(path)
+        unless seen[name] then
+          list << [source_type, source_name, dir, name]
+          seen[name] = true
+        end
+      end
+    end
+
+    list
+  end
+
+  def list_templates
+    puts "List of available templates (to use with the -t TEMPLATE option):"
+
+    default = Configuration.new(ConfigPath).default_template
+    templates.sort_by { |source_type, source_name, dir, name|
+      name
+    }.each do |source_type, source_name, dir, name|
+      default_addon = (default == name) ? ', default' : ''
+      case source_type
+        when :gem     then puts "- #{name} (from gem '#{source_name}'#{default_addon})"
+        when :bundled then puts "- #{name} (bundled with gem-new#{default_addon})"
+        when :user    then puts "- #{name} (user template#{default_addon})"
+        else raise "Unknown source type #{source_type.inspect}"
+      end
+    end
+  end
+
+  def list_variables(variables)
+    path_vars    = variables[:path_vars]
+    content_vars = variables[:content_vars]
+    longest_key  = (path_vars.keys+content_vars.keys).map { |key| key.length }.max
+
+    puts "Path variables:"
+    path_vars.each do |key, value|
+      printf "%-*s %p\n", longest_key, key, value
+    end
+    puts "\nContent variables:"
+    content_vars.each do |key, value|
+      printf "%-*s %p\n", longest_key, key, value
+    end
+  end
+
+  def generate_gem
+    configuration   = Configuration.new(ConfigPath)
+    gem_name        = get_one_optional_argument
+    abort("Must provide a gem name") unless gem_name
+    gem_root        = File.expand_path(Dir.getwd)
+    gem_path        = File.join(gem_root, gem_name)
+    template_name   = options[:template] || configuration.default_template
+    includes        = [[template_name]]
+    skeletons       = []
+    until includes.empty?
+      include_chain = includes.shift
+      skeleton_name = include_chain.last
+      skeleton_path = template_path(skeleton_name)
+      abort("No template named '#{skeleton_name}' found") unless skeleton_path
+      skeleton      = Skeleton.new(skeleton_path)
+      new_includes  = skeleton.includes
+      abort("Circular include found") unless (new_includes & include_chain).empty?
+      includes.concat(new_includes.map { |skeleton_name| include_chain+[skeleton_name] })
+      skeletons << skeleton
+    end
+
+    if File.exist?(gem_path) then
+      exit unless prompt("A directory '#{gem_path}' already exists, continue?", :no)
+      puts "Updating gem '#{gem_name}' in '#{gem_root}"
+    else
+      puts "Creating gem '#{gem_name}' in '#{gem_root}"
+    end
+
+    puts "Using the '#{template_name}' directory skeleton"
+
+    puts "", "Please enter the gem description, terminate with enter and ctrl-d"
+    description = $stdin.read
+    puts "", "Please enter the gem summary, terminate with enter and ctrl-d"
+    summary = $stdin.read
+    puts
+
+    now       = Time.now
+    variables = {
+      :path_vars    => symbolize_keys(configuration.path_variables).merge({
+        :GEM_NAME     => gem_name,
+        :REQUIRE_NAME => gem_name,
+        :YEAR         => now.year,
+        :MONTH        => now.month,
+        :DAY          => now.day,
+        :DATE         => now.strftime("%Y-%m-%d"),
+      }),
+      :content_vars => symbolize_keys(configuration.content_variables).merge({
+        :gem_name     => gem_name,
+        :require_name => gem_name,
+        :now          => now,
+        :namespace    => camelcase(gem_name),
+        :version      => configuration.initial_version,
+        :description  => description,
+        :summary      => summary,
+        :date         => now.strftime("%Y-%m-%d"),
+      }),
+    }
+
+    if options[:variables] then
+      list_variables(variables)
+    else
+      skeletons.reverse_each do |skeleton| # reverse_each?
+        puts "Template #{skeleton.name}"
+        skeleton.materialize(gem_path, variables) do |path, new_content|
+          interactive_materialization(path, new_content, configuration)
+        end
+      end
+    end
+  end
+
+  def interactive_materialization(path, new_content, configuration)
+    old_content = File.read(path)
+    return false if old_content == new_content
+
+    while result.nil?
+      print("File already exists, replace? ([N]o, [y]es, [d]iff) ")
+      $stdout.flush
+      case $stdin.gets
+        when nil then abort("Terminated")
+        when /^y(?:es)?$/i then return true
+        when /^n(?:o)?$/i then return false
+        when /^d(?:iff)?$/i then puts Open3.popen3(configuration.diff_tool % path) { |i,o,e| i.puts new_content; i.close; o.read }
+        else puts "Invalid reply"
+      end
+    end
+  end
+
+  def prompt(question, default=:yes)
+    print "#{question} #{default == :yes ? '([Y]es, [n]o)' : '([N]o, [y]es)'} "
+    $stdout.flush
+    if default == :yes then
+      $stdin.gets !~ /^n(?:o)?\b/i
+    else
+      $stdin.gets =~ /^y(?:es)?\b/i
+    end
+  end
+
+  def generate_default_config
+    yaml = <<-YAML.gsub(/^      /, '')
+      ---
+      # used to migrate configurations automatically
+      config_version:   #{ConfigVersion}
+      # the template used without -t option
+      default_template: default
+      # the diff command used to show diffs on update, %s is the path to the old file
+      diff_tool:        diff -y --label old --label new %s -
+      # whether a diff should be shown right away in updates, without asking first
+      auto_diff:        true
+      # content variables are used for subsitution in template files, also see path_variables
+      content_variables:
+        author:         #{ENV["USER"] || 'unknown author'}
+        #email:          "your.email@address"
+      # content variables are used for subsitution in template paths, also see content_variables
+      path_variables: {}
+    YAML
+    FileUtils.mkdir_p(File.dirname(ConfigPath))
+    File.open(ConfigPath, 'wb') { |fh| fh.write(yaml) }
+  end
+
+  def template_glob(name='*')
+    "{#{TemplateDirs.map { |dir| dir.last }.join(',')}}/#{name}"
+  end
+
+  def template_path(name)
+    Dir.glob(template_glob(name)) do |path|
+      return path
+    end
+    nil
+  end
+
+  def symbolize_keys(hash)
+    Hash[hash.map{|k,v|[k.to_sym,v]}]
+  end
+
+  def camelcase(string)
+    string.gsub(/(?:^|_)([a-z])/) { |m| $1.upcase }
+  end
+end

data/lib/gem/commands/new_command/blank_slate.rb

@@ -0,0 +1,124 @@
+require 'stringio'
+
+
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#
+# Enhanced by Stefan Rusterholz (stefan.rusterholz@gmail.com)
+#++
+
+class Gem::Commands::NewCommand < Gem::Command
+  ######################################################################
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  #
+  class BlankSlate
+    class << self
+      
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+        verbosity = $VERBOSE
+        stderr    = $stderr
+        $VERBOSE  = nil
+        $stderr   = StringIO.new
+
+        methods = instance_methods.map(&:to_sym)
+        if methods.include?(name.to_sym) and
+          name !~ /^(__|instance_eval)/
+          @hidden_methods ||= {}
+          @hidden_methods[name.to_sym] = instance_method(name)
+          undef_method name
+        end
+      ensure
+        $VERBOSE = verbosity
+        $stderr  = stderr
+      end
+  
+      def find_hidden_method(name)
+        @hidden_methods ||= {}
+        @hidden_methods[name] || superclass.find_hidden_method(name)
+      end
+  
+      # Redefine a previously hidden method so that it may be called on a blank
+      # slate object.
+      def reveal(name)
+        hidden_method = find_hidden_method(name)
+        fail "Don't know how to reveal method '#{name}'" unless hidden_method
+        define_method(name, hidden_method)
+      end
+    end
+    
+    instance_methods.each { |m| hide(m) }
+  end
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias gemnew_blank_slate_method_added method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = gemnew_blank_slate_method_added(name)
+      return result if self != Kernel
+      Gem::Commands::NewCommand::BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias gemnew_blank_slate_method_added method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = gemnew_blank_slate_method_added(name)
+      return result if self != Object
+      Gem::Commands::NewCommand::BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias gemnew_blank_slate_original_append_features append_features
+  def append_features(mod)
+    result = gemnew_blank_slate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      Gem::Commands::NewCommand::BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/gem/commands/new_command/configuration.rb

@@ -0,0 +1,31 @@
+class Gem::Commands::NewCommand < Gem::Command
+  class Configuration
+    def initialize(config_path)
+      @config = YAML.load_file(config_path)
+    end
+
+    def diff_tool
+      @config['diff_tool']
+    end
+
+    def content_variables
+      @config['content_variables']
+    end
+
+    def path_variables
+      @config['path_variables']
+    end
+
+    def default_template
+      @config['default_template']
+    end
+
+    def config_version
+      @config['config_version']
+    end
+
+    def initial_version
+      "0.0.1"
+    end
+  end
+end

data/lib/gem/commands/new_command/erb_template.rb

@@ -0,0 +1,193 @@
+require 'erb'
+require 'gem/commands/new_command/blank_slate'
+
+
+
+class Gem::Commands::NewCommand < Gem::Command
+
+  # = Indexing
+  # Author:   Stefan Rusterholz
+  # Contact:  contact@apeiros.me
+  # Version:  0.1.0
+  #
+  # = About
+  # A helper class for ERB, allows constructs like the one in the Synopsis to
+  # enable simple use of variables/methods in templates.
+  #
+  # = Synopsis
+  #   tmpl = Templater.new("Hello <%= name %>!")
+  #   tmpl.result(self, :name => 'world') # => 'Hello World!'
+  #
+  class ErbTemplate
+
+    # = Indexing
+    # Author:   Stefan Rusterholz
+    # Contact:  contact@apeiros.me
+    # Version:  0.1.0
+    #
+    # = About
+    # Similar to OpenStruct, but slightly optimized for create once, use once and
+    # giving diagnostics on exceptions/missing keys.
+    #
+    # = Synopsis
+    #   tmpl = Variables.new(delegator, :variable => "content") { |exception|
+    #     do_something_with(exception)
+    #   }
+    #
+    class Variables < BlankSlate
+      # A proc for &on_error in SilverPlatter::Variables::new or SilverPlatter::Templater#result.
+      # Raises the error further on.
+      Raiser = proc { |e|
+        raise(e)
+      }
+
+      # A proc for &on_error in SilverPlatter::Variables.new or SilverPlatter::Templater#result.
+      # Inserts <<error_class: error_message>> in the place where the error
+      # occurred.
+      Teller = proc { |e|
+        "<<#{e.class}: #{e}>>"
+      }
+
+      # An empty Hash
+      EmptyHash     = {}.freeze
+
+      # Regex to match setter method names
+      SetterPattern = /=\z/.freeze
+
+      # === Arguments
+      # * delegate:      All method calls and undefined variables are delegated to this object as method call.
+      # * variables:     A hash with variables in it, keys must be Symbols.
+      # * on_error_name: Instead of a block you can pass the name of an existing handler, e.g. :Raiser or :Teller.
+      # * &on_error:     The block is yielded in case of an exception with the exception as argument
+      #
+      def initialize(delegate=nil, variables={}, on_error_name=nil, &on_error)
+        @delegate = delegate
+        @table    = (@delegate ? Hash.new { |h,k| @delegate.send(k) } : EmptyHash).merge(variables)
+        if !on_error && on_error_name then
+          @on_error = self.class.const_get(on_error_name)
+        else
+          @on_error = on_error || Raiser
+        end
+      end
+
+      # All keys this Variables instance provides, if the include_delegate argument is true and
+      # the object to delegate to responds to __keys__, then it will add the keys of the delegate.
+      def __keys__(include_delegate=true)
+        @table.keys + ((include_delegate && @delegate.respond_to?(:__keys__)) ? @delegate.__keys__ : [])
+      end
+
+      def __binding__
+        binding
+      end
+
+      # See Object#respond_to?
+      def respond_to?(key)
+        @table.respond_to?(key) || (@delegate && @delegate.respond_to?(key)) || super
+      end
+
+      def method_missing(m, *args) # :nodoc:
+        argn = args.length
+        if argn.zero? && @table.has_key?(m) then
+          @table[m]
+        elsif argn == 1 && m.to_s =~ SetterPattern
+          @table[m] = args.first
+        elsif @delegate
+          @delegate.send(m, *args)
+        end
+      rescue => e
+        @on_error.call(e)
+      end
+
+      def inspect # :nodoc:
+        sprintf "#<%s:0x%08x @delegate=%s %s>",
+          self.class,
+          __id__,
+          @table.map { |k,v| "#{k}=#{v.inspect}" }.join(', '),
+          @delegate ? "#<%s:0x%08x ...>" %  [@delegate.class, @delegate.object_id << 1] : "nil"
+      end
+    end
+
+    # Option defaults
+    Opt = {
+      :safe_level => nil,
+      :trim_mode  => '%<>',
+      :eoutvar    => '_erbout'
+    }
+
+    # binding method
+    Binder          = Object.instance_method(:binding)
+    InstanceEvaler  = Object.instance_method(:instance_eval)
+
+
+    # A proc for &on_error in SilverPlatter::Variables::new or SilverPlatter::Templater#result.
+    # Raises the error further on.
+    Raiser = proc { |e|
+      raise
+    }
+
+    # A proc for &on_error in SilverPlatter::Variables.new or SilverPlatter::Templater#result.
+    # Inserts <<error_class: error_message>> in the place where the error
+    # occurred.
+    Teller = proc { |e|
+      "<<#{e.class}: #{e}>>"
+    }
+
+    # The template string
+    attr_reader :string
+
+    # Like Templater.new, but instead of a template string, the path to the file
+    # containing the template. Sets :filename.
+    def self.file(path, opt=nil)
+      new(File.read(path), (opt || {}).merge(:filename => path))
+    end
+
+    def self.replace(template, variables, &on_error)
+      new(template).result(nil, variables, &on_error)
+    end
+
+    # ==== Arguments
+    # * string: The template string, it becomes frozen
+    # * opt:    Option hash, keys:
+    #   * :filename:   The filename used for the evaluation (useful for error messages)
+    #   * :safe_level: see ERB.new
+    #   * :trim_mode:  see ERB.new
+    #   * :eoutvar:    see ERB.new
+    def initialize(string, opt={})
+      opt, string   = string, nil if string.kind_of?(Hash)
+      opt           = Opt.merge(opt)
+      file          = opt.delete(:filename)
+      @string       = string.freeze
+      @erb          = ERB.new(@string, *opt.values_at(:safe_level, :trim_mode, :eoutvar))
+      @erb.filename = file if file
+    end
+
+    # See Templater::Variables.new
+    # Returns the evaluated template. Default &on_error is the Templater::Raiser
+    # proc.
+    def result(delegate=nil, variables={}, on_error_name=nil, &on_error)
+      variables ||= {}
+      on_error  ||= Raiser
+      variables = Variables.new(delegate, variables, on_error_name, &on_error)
+      @erb.result(variables.__binding__)
+    rescue NameError => e
+      raise NameError, e.message+" for #{self.inspect} with #{variables.inspect}", e.backtrace
+    end
+
+    def result_with(opt, &block)
+      variables     = opt.delete(:variables) || {}
+      on_error      = opt.delete(:on_error) || Raiser
+      on_error_name = opt.delete(:on_error_name) || Raiser
+      variables = Variables.new(delegate, variables, on_error_name, block, &on_error)
+      @erb.result(variables.__binding__)
+    rescue NameError => e
+      raise NameError, e.message+" for #{self.inspect} with #{variables.inspect}", e.backtrace
+    end
+
+    def inspect # :nodoc:
+      sprintf "#<%s:0x%x string=%s>",
+        self.class,
+        object_id << 1,
+        @string.inspect
+    end
+  end
+end

data/lib/gem/commands/new_command/skeleton.rb

@@ -0,0 +1,129 @@
+require 'erb'
+require 'fileutils'
+require 'gem/commands/new_command/string_replacer'
+require 'gem/commands/new_command/erb_template'
+
+
+
+class Gem::Commands::NewCommand < Gem::Command
+  class Skeleton
+    DefaultOptions  = {
+      :verbose  => false,
+      :silent   => false,
+      :out      => $stdout,
+    }
+    Processors = {}
+    Processor  = Struct.new(:suffix, :name, :execute)
+    
+    def self.register_processor(suffix, name, &execute)
+      Processors[suffix] = Processor.new(suffix, name, execute)
+    end
+
+    register_processor '.literal', 'Literal' do |template, variables|
+      template
+    end
+    register_processor '.erb', 'ERB' do |template, variables|
+      ErbTemplate.replace(template, variables)
+    end
+
+    attr_reader :name
+    attr_reader :meta
+    attr_reader :base_path
+    attr_reader :source_slice
+    attr_reader :directories
+    attr_reader :files
+
+    def initialize(path, options=nil)
+      @name                 = File.basename(path)
+      @options              = options ? DefaultOptions.merge(options) : DefaultOptions.dup
+      @meta_path            = File.join(path, 'meta.yaml')
+      @meta                 = File.exist?(@meta_path) ? YAML.load_file(@meta_path) : {}
+      @base_path            = path
+      @source_slice         = (path.length+10)..-1
+      contents              = Dir[File.join(path, "skeleton", "**", "{*,.gitkeep}")].sort
+      @directories, @files  = contents.partition { |path|
+        File.directory?(path)
+      }
+      @verbose              = @options.delete(:verbose)
+      @silent               = @options.delete(:silent)
+      @out                  = @options.delete(:out)
+      raise ArgumentError, "Unknown options: #{@options.keys.join(', ')}" unless @options.empty?
+    end
+
+    def includes
+      @meta['includes'] || []
+    end
+
+    def materialize(in_path, env={}, &on_collision)
+      target_slice  = (in_path.length+1)..-1
+      path_replacer = StringReplacer.new(env[:path_vars] || {})
+      content_vars  = env[:content_vars] || {}
+
+      unless File.exist?(in_path) then
+        info "Creating root '#{in_path}'"
+        FileUtils.mkdir_p(in_path)
+      end
+
+      if @directories.empty? then
+        info "No directories to create"
+      else
+        info "Creating directories"
+        @directories.each do |source_dir_path|
+          target_dir_path = source_to_target_path(source_dir_path, in_path, path_replacer)
+          info "  #{target_dir_path[target_slice]}"
+          FileUtils.mkdir_p(target_dir_path)
+        end
+      end
+
+      if @files.empty? then
+        info "No files to create"
+      else
+        info "Creating files"
+        @files.each do |source_file_path|
+          target_file_path, processors = source_to_target_path_and_processors(source_file_path, in_path, path_replacer)
+          content = processors.inject(File.read(source_file_path)) { |data, processor|
+            processor.execute.call(data, content_vars)
+          }
+          info "  #{target_file_path[target_slice]}"
+          if !File.exist?(target_file_path) || (block_given? && yield(target_file_path, content)) then
+            File.open(target_file_path, 'wb') do |fh|
+              fh.write(content)
+            end
+          end
+        end
+      end
+    end
+
+    def source_to_target_path(source_path, target_dir, replacer)
+      File.join(target_dir, replacer.replace(source_path[@source_slice]))
+    end
+
+    def source_to_target_path_and_processors(source_path, target_dir, replacer)
+      replaced_source   = replacer.replace(source_path[@source_slice])
+      extname           = File.extname(replaced_source)
+      processors        = []
+      processed_source  = replaced_source
+
+      if processor = Processors[extname] then
+        processors      << processor
+        processed_source = processed_source.chomp(extname)
+      end
+      target_path = File.join(target_dir, processed_source)
+#       while processor = Processors[extname]
+#         processors       << processor
+#         processed_source  = File.basename(processed_source, extname)
+#         extname           = File.extname(processed_source)
+#       end
+
+      [target_path, processors]
+    end
+
+  private
+    def info(msg)
+      @out.puts msg unless @silent
+    end
+    def debug(msg)
+      @out.puts msg if @verbose
+    end
+  end
+end

data/lib/gem/commands/new_command/string_replacer.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+class Gem::Commands::NewCommand < Gem::Command
+  class StringReplacer
+    def self.replace(string, variables)
+      new(variables).replace(string)
+    end
+
+    def initialize(variables)
+      @variables = Hash[variables.map { |k,v| [k.to_s, v.to_s] }] # convert keys and values to strings
+      @pattern   = Regexp.union(@variables.keys.map { |var| Regexp.escape(var) })
+    end
+
+    begin
+      "hi".gsub(/./u, {})
+    rescue TypeError # ruby 1.8
+      def replace(string)
+        string.gsub(@pattern) { |m| @variables[m] }
+      end
+    else # ruby 1.9
+      def replace(string)
+        string.gsub(@pattern, @variables)
+      end
+    end
+  end
+end

data/lib/gem/commands/new_command/version.rb

@@ -0,0 +1,3 @@
+class Gem::Commands::NewCommand < Gem::Command
+  VERSION = Gem::Version.new("0.1.0")
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,4 @@
+require 'rubygems/command_manager'
+require 'gem/commands/new_command'
+
+Gem::CommandManager.instance.register_command :new

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: gem-new
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Rusterholz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-10 00:00:00.000000000 Z
+dependencies: []
+description: ! '    Gem-new is a gem command plugin that allows you to easily create
+  a new gem.'
+email: stefan.rusterholz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- data/gem-new/default/meta.yaml
+- data/gem-new/default/skeleton/GEM_NAME.gemspec.erb
+- data/gem-new/default/skeleton/lib/REQUIRE_NAME/version.rb.erb
+- data/gem-new/default/skeleton/lib/REQUIRE_NAME.rb.erb
+- data/gem-new/default/skeleton/Rakefile
+- data/gem-new/default/skeleton/README.markdown.literal
+- data/gem-new/default/skeleton/README_DIRECTORIES
+- data/gem-new/gem-new-template/meta.yaml
+- data/gem-new/gem-new-template/skeleton/data/GEM_NAME/your_template_name/meta.yaml
+- data/gem-new/default/skeleton/bin/.gitkeep
+- data/gem-new/default/skeleton/development/.gitkeep
+- data/gem-new/default/skeleton/documentation/.gitkeep
+- data/gem-new/default/skeleton/lib/.gitkeep
+- data/gem-new/default/skeleton/rake/lib/.gitkeep
+- data/gem-new/default/skeleton/rake/tasks/.gitkeep
+- data/gem-new/default/skeleton/test/.gitkeep
+- data/gem-new/gem-new-template/skeleton/data/GEM_NAME/your_template_name/skeleton/.gitkeep
+- lib/gem/commands/new_command/blank_slate.rb
+- lib/gem/commands/new_command/configuration.rb
+- lib/gem/commands/new_command/erb_template.rb
+- lib/gem/commands/new_command/skeleton.rb
+- lib/gem/commands/new_command/string_replacer.rb
+- lib/gem/commands/new_command/version.rb
+- lib/gem/commands/new_command.rb
+- lib/rubygems_plugin.rb
+homepage: http://github.com/apeiros/gem-new
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Create new gems easily
+test_files: []