tap-gen 0.1.0

data/History

@@ -0,0 +1,4 @@
+== 0.1.0 / 2009-05-25
+
+Extracted from Tap-0.12.0, with updates for
+Tap-0.17.0

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009, Regents of the University of Colorado.
+
+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

@@ -0,0 +1,57 @@
+= {Tap Generator}[http://tap.rubyforge.org/tap-gen]
+
+  gen.er.a.tor n. a thing that generates something
+  
+Generators for Tap.
+
+== Description
+
+Provides generators for Tap. Generators are subclasses of Task are therefore
+easy to configure, subclass, and distribute.
+{Tap-Generator}[http://tap.rubyforge.org/tap-gen] is a part of the
+{Tap-Suite}[http://tap.rubyforge.org/tap-suite]. Check out these links for
+documentation, development, and bug tracking.
+
+* Website[http://tap.rubyforge.org]
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/9908-tap-task-application/tickets]
+* Github[http://github.com/bahuvrihi/tap/tree/master]
+* {Google Group}[http://groups.google.com/group/ruby-on-tap]
+
+== Usage
+
+Get started:
+ 
+  % tap generate root sample
+  % cd sample
+  % tap generate task goodnight
+  % tap run -- goodnight moon
+
+Get some help:
+
+  % tap generate --help
+  % tap generate task --help
+
+Roll your own:
+
+  % tap generate generator thing
+
+Roll it back:
+
+  % tap destroy generator thing
+  % tap destroy task goodnight
+  % cd ..
+  % tap destroy root sample
+
+== Installation
+
+Tap-Generator is available as a gem on
+RubyForge[http://rubyforge.org/projects/tap]. Use:
+
+  % gem install tap-gen
+  
+== Info
+
+Copyright (c) 2009, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/cmd/destroy.rb

@@ -0,0 +1,21 @@
+# usage: tap destroy GENERATOR ...
+#
+# Runs a generator in reverse.  Each generator works a little differently; the
+# best way to figure out what a generator does is to use --help. For example:
+#
+#   % tap generate root --help
+#
+
+require 'tap/generator/exe'
+require 'tap/generator/destroy'
+
+env = Tap::Env.instance
+env.extend Tap::Generator::Exe
+
+env.run(Tap::Generator::Destroy, ARGV) do
+  puts Lazydoc.usage(__FILE__)
+  puts
+  puts "generators:"
+  puts env.manifest('generator').summarize
+  exit(1)
+end

data/cmd/generate.rb

@@ -0,0 +1,21 @@
+# usage: tap generate GENERATOR ...
+#
+# Runs a generator.  Each generator works a little differently; the best way to
+# figure out what a generator does is to use --help. For example:
+#
+#   % tap generate root --help
+#
+
+require 'tap/generator/exe'
+require 'tap/generator/generate'
+
+env = Tap::Env.instance
+env.extend Tap::Generator::Exe
+
+env.run(Tap::Generator::Generate, ARGV) do
+  puts Lazydoc.usage(__FILE__)
+  puts
+  puts "generators:"
+  puts env.manifest('generator').summarize
+  exit(1)
+end

data/lib/tap/generator/arguments.rb

@@ -0,0 +1,13 @@
+module Tap
+  module Generator
+    
+    # A special type of Lazydoc::Arguments that shifts off the standard 'm'
+    # argument on generator manifest methods, to properly reflect how may
+    # arguments the generator should receive.
+    class Arguments < Lazydoc::Arguments
+      def arguments(shift_manifest_arg=true)
+        shift_manifest_arg ? @arguments[1..-1] : @arguments
+      end
+    end
+  end
+end

data/lib/tap/generator/base.rb

@@ -0,0 +1,180 @@
+require 'tap'
+require 'tap/generator/manifest'
+require 'tap/generator/arguments'
+
+module Tap
+  module Generator
+    
+    # :startdoc:::-
+    # Base provides the basic structure of a generator and custom generators
+    # inherit from it.  Base is patterned after the {Ruby on Rails}[http://rubyonrails.org/] 
+    # generators, but obviously takes on all the advantages of Tasks.
+    #
+    # === Usage
+    #
+    # Tap generators define a manifest method that defines what files and
+    # directories are created by the generator.  Then, at execution time,
+    # a mixin with the appropriate funtion (ie Generate or Destroy) is 
+    # overlaid to figure out how to roll those actions forward or backwards.
+    #
+    # Generators are identified using the ::generator flag rather than ::task,
+    # so that generators are available to the generate/destroy commands and
+    # not run.
+    #
+    # Typically, generators live in a directory structure like this:
+    #
+    #   root
+    #   |- lib
+    #   |   `- sample.rb
+    #   |
+    #   `- templates
+    #       `- sample
+    #           `- template_file.erb
+    #
+    # Tap generators keep templates out of lib and under templates, in a
+    # directory is named after the generator class.  Generators themselves
+    # take the form:
+    #
+    #   [sample.rb]
+    #   require 'tap/generator/base'
+    #
+    #   # ::generator generates a directory, and two files
+    #   #
+    #   # An extended description of the
+    #   # generator goes here...
+    #   #
+    #   class Sample < Tap::Generator::Base
+    #
+    #     config :key, 'value'       # a sample config
+    #
+    #     def manifest(m, *args)
+    #       # make a directory
+    #       m.directory('path/to/dir')
+    #
+    #       # make a file
+    #       m.file('path/to/file.txt') do |file|
+    #         file << "some content"
+    #       end
+    #
+    #       # template a file
+    #       m.template('path/to/result.txt', 'template_file.erb', config.to_hash)
+    #     end
+    #   end
+    #
+    # The arguments that a generator receives are specified by manifest (minus
+    # the 'm' argument which is standard) rather than process. Creating
+    # directories and files is straightforward, as above.  Template renders the
+    # erb source file using attributes specified in the last argument; in the
+    # example template uses the generator configurations.
+    #
+    # :startdoc:::+
+    class Base < Tap::Task
+      lazy_attr :manifest, 'generator'
+      lazy_attr :args, :manifest
+      lazy_register :manifest, Arguments
+      
+      config :destination_root, Dir.pwd       # The destination root directory
+      config :pretend, false, &c.flag         # Run but rollback any changes.
+      config :force, false, &c.flag           # Overwrite files that already exist.
+      config :skip, false, &c.flag            # Skip files that already exist.
+      
+      # The generator-specific templates directory.  By default:
+      # 'templates/path/to/name' for 'lib/path/to/name.rb'
+      attr_accessor :template_dir
+      
+      # The IO used to pull prompt inputs (default: $stdin)
+      attr_accessor :prompt_in
+      
+      # The IO used to prompt users for input (default: $stdout)
+      attr_accessor :prompt_out
+      
+      def initialize(config={}, app=Tap::App.instance)
+        super
+        @prompt_in = $stdin
+        @prompt_out = $stdout
+        @template_dir = File.expand_path("templates/#{self.class.to_s.underscore}")
+      end
+      
+      # Builds the manifest, then executes the actions of the manifest.
+      # Process returns the results of iterate, which normally will be
+      # an array of files and directories created (or destroyed) by self.
+      def process(*argv)
+        actions = []
+        manifest(Manifest.new(actions), *argv)
+        
+        iterate(actions) do |action, args, block|
+          send(action, *args, &block)
+        end
+      end
+      
+      # Overridden in subclasses to add actions to the input Manifest.
+      # Any arguments passed to process will be passed to manifest
+      # unchanged.
+      def manifest(m, *argv)
+        raise NotImplementedError
+      end
+      
+      # Peforms each of the input actions in order, and collects the
+      # results.  The process method returns these results.
+      def iterate(actions)
+        actions.collect {|action| yield(action) }
+      end
+      
+      # Constructs a path relative to destination_root.
+      def path(*paths)
+        File.expand_path(File.join(*paths), destination_root)
+      end
+      
+      # Peforms a directory action (ex generate or destroy).  Must be
+      # overridden by one of the action mixins (ex Generate or Destroy).
+      def directory(target, options={})
+        raise NotImplementedError
+      end
+    
+      # Peforms a file action (ex generate or destroy).  Calls to file specify
+      # input for a target by providing a block; the block recieves an IO and
+      # pushes content to it.  Must be overridden by one of the action mixins
+      # (ex Generate or Destroy).
+      def file(target, options={}) # :yields: io
+        raise NotImplementedError
+      end
+      
+      # Makes (or destroys) the root and each of the targets, relative
+      # to root.  Options are passed onto directory.
+      def directories(root, targets, options={})
+        directory(root, options)
+        targets.each do |target|
+          directory(File.join(root, target), options)
+        end
+      end
+      
+      # Makes (or destroys) the target by templating the source using
+      # the specified attributes.  Source is expanded relative to
+      # template_dir.  Options are passed onto file.
+      def template(target, source, attributes={}, options={})
+        template_path = File.expand_path(source, template_dir)
+        templater = Support::Templater.new(File.read(template_path), attributes)
+        
+        file(target, options) do |file| 
+          file << templater.build
+        end
+      end
+      
+      # Yields each source file under template_dir to the block, with
+      # a target path of the source relative to template_dir.
+      def template_files
+        Dir.glob(template_dir + "/**/*").sort.each do |source|
+          next unless File.file?(source)
+          
+          target = Tap::Root::Utils.relative_path(template_dir, source)
+          yield(source, target)
+        end
+      end
+      
+      # Logs the action with the relative filepath from Dir.pwd to path.
+      def log_relative(action, path)
+        log(action, Tap::Root::Utils.relative_path(Dir.pwd, path))
+      end
+    end
+  end
+end

data/lib/tap/generator/destroy.rb

@@ -0,0 +1,60 @@
+module Tap
+  module Generator
+    
+    # A mixin defining how to run manifest actions in reverse.
+    module Destroy
+      
+      # Iterates over the actions in reverse, and collects the results.
+      def iterate(actions)
+        results = []
+        actions.reverse_each {|action| results << yield(action) }
+        results
+      end
+      
+      # Removes the target directory if it exists.  Missing, non-directory and 
+      # non-empty targets are simply logged and not removed.  When pretend is
+      # true, removal is logged but does not actually happen.
+      #
+      # No options currently affect the behavior of this method. 
+      def directory(target, options={})
+        target = File.expand_path(target)
+        
+        case
+        when !File.exists?(target)
+          log_relative :missing, target
+        when !File.directory?(target)
+          log_relative 'not a directory', target
+        when !Root::Utils.empty?(target)
+          log_relative 'not empty', target
+        else
+          log_relative :rm, target
+          FileUtils.rmdir(target) unless pretend
+        end
+        
+        target
+      end
+      
+      # Removes the target file if it exists.  Missing and non-file and targets
+      # are simply logged and not removed.  When pretend is true, removal is 
+      # logged but does not actually happen.
+      #
+      # No options currently affect the behavior of this method.
+      def file(target, options={})
+        target = File.expand_path(target)
+        
+        case
+        when File.file?(target)
+          log_relative :rm, target
+          FileUtils.rm(target) unless pretend
+        when File.directory?(target)
+          log_relative 'not a file', target
+        else
+          log_relative :missing, target
+        end
+        
+        target
+      end
+      
+    end
+  end
+end

data/lib/tap/generator/exe.rb

@@ -0,0 +1,27 @@
+require 'tap/generator/base'
+
+module Tap
+  module Generator
+    
+    # Methods used by the generate and destroy commands.
+    module Exe
+      
+      def run(mod, argv=ARGV)
+        if argv.empty? || argv == ['--help']
+          yield
+        end
+        
+        name = argv.shift
+        env, const = eeek('generator', name)
+        
+        unless const
+          raise "unknown generator: #{name}"
+        end
+        
+        generator, argv = const.constantize.parse(argv)
+        generator.template_dir = env.class_path(:templates, generator) {|dir| File.directory?(dir) }
+        generator.extend(mod).process(*argv)
+      end
+    end
+  end
+end

data/lib/tap/generator/generate.rb

@@ -0,0 +1,93 @@
+autoload(:Tempfile, 'tempfile')
+
+module Tap
+  module Generator
+    
+    # A mixin defining how to run manifest actions.
+    module Generate
+      
+      # Creates the target directory if it doesn't exist.  When pretend is
+      # true, creation is logged but does not actually happen.
+      #
+      # No options currently affect the behavior of this method.
+      def directory(target, options={})
+        target = File.expand_path(target)
+        
+        case
+        when File.exists?(target)
+          log_relative :exists, target
+        else
+          log_relative :create, target
+          FileUtils.mkdir_p(target) unless pretend
+        end
+        
+        target
+      end
+      
+      # Creates the target file; content may be added to the file by providing
+      # block.  If the target file already exists, the new and existing content
+      # is compared and the user will be prompted for how to handle collisions.
+      # All activity is logged.  When pretend is true, creation is logged but
+      # does not actually happen.
+      #
+      # No options currently affect the behavior of this method.
+      def file(target, options={})
+        source_file = Tempfile.new('generate')
+        yield(source_file) if block_given?
+        source_file.close
+        
+        source = source_file.path
+        target = File.expand_path(target)
+        
+        copy_file = true
+        msg = case
+        when !File.exists?(target)
+          :create
+        when FileUtils.cmp(source, target)
+          :exists
+        when force_file_collision?(target)
+          :force
+        else
+          copy_file = false
+          :skip
+        end
+        
+        log_relative msg, target
+        if copy_file && !pretend
+          dir = File.dirname(target)
+          FileUtils.mkdir_p(dir) unless File.exists?(dir) 
+          FileUtils.mv(source, target, :force => true)
+        end
+        
+        target
+      end
+      
+      protected
+      
+      # Ask the user interactively whether to force collision.
+      def force_file_collision?(target)
+        return false if skip
+        return true if force
+        
+        prompt_out.print "overwrite #{target}? [Ynaiq] "
+        prompt_out.flush
+        case prompt_in.gets.strip
+        when /^y(es)?$/i
+          true
+        when /^n(o)?$/i
+          false
+        when /^a(ll)?$/i
+          self.force = true
+          true
+        when /^i(gnore)?$/i
+          self.skip = true
+          false
+        when /^q(uit)?$/i
+          prompt_out.puts "aborting"
+          raise SystemExit
+        else force_file_collision?(target)
+        end
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/command.rb

@@ -0,0 +1,19 @@
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a new tap command
+  #
+  # Generates a new tap command under the cmd directory. The  
+  # new command can be run from the command line using:
+  # 
+  #   % tap <command>
+  #
+  class Command < Tap::Generator::Base
+    def manifest(m, command_name)
+      m.directory path('cmd')
+      
+      template_files do |source, target|
+        m.template path('cmd', "#{command_name}.rb"), source, :command_name => command_name
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/config.rb

@@ -0,0 +1,118 @@
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a config file generator
+  # 
+  # Generates a new config file for a task.  The configurations, defaults, 
+  # and documentation is determined from the source file.
+  #
+  # Configurations for other types of configurable resources may also be
+  # generated.  Specify the constant attribute identifying the resource
+  # using the 'resource' flag.  This generates a config file for the Root
+  # generator:
+  #
+  #   % tap generate config root --resource generator
+  #
+  class Config < Tap::Generator::Base
+    
+    dump_delegates = lambda do |leader, delegate, block|
+      nested_delegates = delegate.default(false).delegates
+      indented_dump = Configurable::Utils.dump(nested_delegates, &block).gsub(/^/, "  ")
+      "#{leader}: \n#{indented_dump}"
+    end
+    
+    doc_format = lambda do |key, delegate|
+      # get the description
+      desc = delegate.attributes[:desc]
+      doc = desc.to_s
+      doc = desc.comment if doc.empty?
+    
+      # wrap as lines
+      lines = Lazydoc::Utils.wrap(doc, 50).collect {|line| "# #{line}"}
+      lines << "" unless lines.empty?
+      
+      if delegate.is_nest?
+        leader = "#{lines.join("\n")}#{key}"
+        DUMP_DELEGATES[leader, delegate, DOC_FORMAT]
+      else
+        default = delegate.default
+        
+        # setup formatting
+        leader = default == nil ? '# ' : ''
+        config = YAML.dump({key => default})[5..-1]
+        "#{lines.join("\n")}#{leader}#{config.strip}\n\n"
+      end
+    end
+    
+    nodoc_format = lambda do |key, delegate|
+      if delegate.is_nest?
+        DUMP_DELEGATES[key, delegate, NODOC_FORMAT]
+      else
+        default = delegate.default
+      
+        # setup formatting
+        leader = default == nil ? '# ' : ''
+        config = YAML.dump({key => default})[5..-1]
+        "#{leader}#{config.strip}\n"
+      end
+    end
+    
+    # Dumps a nested configuration.
+    DUMP_DELEGATES = dump_delegates
+    
+    # Dumps configurations as YAML with documentation,
+    # used when the doc config is true.
+    DOC_FORMAT = doc_format
+    
+    # Dumps configurations as YAML without documentation, 
+    # used when the doc config is false.
+    NODOC_FORMAT = nodoc_format
+    
+    config :doc, true, &c.switch        # include documentation in the config
+    config :nest, false, &c.switch      # generate nested config files
+    config :blanks, true, &c.switch     # allow generation of empty config files
+    config :resource, 'task'            # specify the resource type
+    
+    # Lookup the named resource class.  Lookup happens through the active Env 
+    # instance, specifically using:
+    #
+    #   Env.instance.constant_manifest(resource)[name]
+    #
+    # Raises an error if the name cannot be resolved to a resource.
+    def lookup(name)
+      env = Tap::Env.instance
+      env.constant_manifest(resource)[name] or raise "unknown #{resource}: #{name}"
+    end
+    
+    def manifest(m, name, config_name=nil)
+      # setup
+      tasc = lookup(name)
+      config_name ||= tasc.to_s.underscore
+      config_file = path('config', config_name)
+      config_file += ".yml" if File.extname(config_file).empty?
+      
+      # generate the dumps
+      dumps = Configurable::Utils.dump_file(
+        tasc.configurations,
+        config_file, 
+        nest, 
+        true, 
+        &format_block)
+      
+      # now put the dumps to the manifest
+      m.directory(path('config'))
+      
+      dumps.each do |path, content|
+        next if content.empty? && !blanks
+        m.file(path) do |file|
+          file << content
+        end
+      end
+    end
+    
+    # A hook to set a formatting block.  By default format_blocks
+    # returns DOC_FORMAT or NODOC_FORMAT as per the doc config.
+    def format_block
+      doc ? DOC_FORMAT : NODOC_FORMAT
+    end
+  end
+end

data/lib/tap/generator/generators/generator.rb

@@ -0,0 +1,28 @@
+require 'tap/generator/generators/task'
+
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a generator task and test
+  #
+  # Generates a new generator.
+  class Generator < Tap::Generator::Generators::Task
+    
+    config :test, true, &c.switch  # specifies creation of a test file
+    
+    def manifest(m, const_name)
+      super
+      
+      const = Tap::Env::Constant.new(const_name.camelize)
+      
+      # make the templates directory
+      m.directory path('templates', const.path)
+      
+      # make a template file
+      # (note it's easier to do this as a file since erb is
+      # added, and would have to be escaped in a template)
+      m.file path('templates', const.path, 'template_file.erb') do |file|
+        file << "# A sample template file.\nkey: <%= key %>\n"
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/root.rb

@@ -0,0 +1,96 @@
+require 'tap/generator/base'
+require 'tap/constants'
+
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a basic tap directory structure
+  #
+  # Generates a tap root directory structure.  Use the switches to turn on or
+  # off the creation of various files:
+  #
+  #   project
+  #   |- MIT-LICENSE
+  #   |- README
+  #   |- Rakefile
+  #   |- lib
+  #   |- project.gemspec
+  #   |- tap.yml
+  #   `- test
+  #       `- tap_test_helper.rb
+  #
+  class Root < Tap::Generator::Base
+    
+    nest :gemspec do
+      config :name, "Your Name Here"               # Author name
+      config :email, "your.email@pubfactory.edu"   # Author email
+      config :homepage, ""                         # The project hompage
+      config :rubyforge_project, ""                # The rubyforge project name
+      config :summary, ""                          # The project summary
+    end
+    
+    config :env, false, &c.switch          # Create a full tap.yml file
+    config :license, true, &c.switch       # Create an MIT-LICENSE
+    config :history, true, &c.switch       # Create History file
+    config :rapfile, false, &c.switch      # Create a Rapfile
+    config :rakefile, true, &c.switch      # Create a Rakefile
+    
+    # ::args ROOT, PROJECT_NAME=basename(ROOT)
+    def manifest(m, root, project_name=nil)
+      r = Tap::Root.new(root)
+      project_name = File.basename(r.root) if project_name == nil
+      
+      m.directory r.root
+      m.directory r['lib']
+      m.directory r['test']
+      
+      template_files do |source, target|
+        case
+        when File.directory?(source)
+          m.directory r[target]
+          next
+        when source =~ /gemspec$/
+          locals = gemspec.config.to_hash.merge(
+            :project_name => project_name, 
+            :license => license,
+            :history => history
+          )
+          m.template r[project_name + '.gemspec'], source, locals
+          next
+        when source =~ /Rakefile$/
+          next unless rakefile
+        when source =~ /Rapfile$/
+          next unless rapfile
+        when source =~ /MIT-LICENSE$/
+          next unless license
+        end
+        
+        m.template r[target], source, :project_name => project_name, :license => license
+      end
+      
+      m.file(r['History']) if history
+      m.file(r['tap.yml']) do |file|
+        Configurable::Utils.dump(Tap::Env.configurations, file) do |key, delegate|
+          default = delegate.default(false)
+          
+          # get the description
+          desc = delegate.attributes[:desc]
+          doc = desc.to_s
+          doc = desc.comment if doc.empty?
+          
+          # wrap as lines
+          lines = Lazydoc::Utils.wrap(doc, 78).collect {|line| "# #{line}"}
+          lines << "" unless lines.empty?
+          
+          # note: this causes order to be lost...
+          default = default.to_hash if delegate.is_nest?
+
+          # setup formatting
+          leader = key == 'root' || default == nil ? '# ' : ''
+          config = YAML.dump({key => default})[5..-1].strip.gsub(/\n+/, "\n#{leader}")
+          "#{lines.join("\n")}#{leader}#{config}\n\n"
+        end if env
+      end
+    end
+    
+  end
+end

data/lib/tap/generator/generators/task.rb

@@ -0,0 +1,27 @@
+require 'tap/env'
+
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a task and test
+  #
+  # Generates a new Tap::Task and an associated test file.
+  class Task < Tap::Generator::Base
+    
+    config :test, true, &c.switch  # specifies creation of a test file
+    
+    def manifest(m, const_name)
+      const = Tap::Env::Constant.new(const_name.camelize)
+      
+      task_path = path('lib', "#{const.path}.rb")
+      m.directory File.dirname(task_path)
+      m.template task_path, "task.erb", :const => const
+      
+      if test
+        test_path = path('test', "#{const.path}_test.rb")
+        m.directory File.dirname(test_path)
+        m.template test_path, "test.erb", :const => const
+      end
+    end
+
+  end
+end

data/lib/tap/generator/manifest.rb

@@ -0,0 +1,20 @@
+module Tap
+  module Generator
+    
+    # Manifest records methods called upon it using method_missing.  These
+    # actions are replayed on a generator in order (for generate) or in
+    # reverse order (for destroy).
+    class Manifest
+      
+      # Makes a new Manifest.  Method calls on self are recorded to actions.
+      def initialize(actions)
+        @actions = actions
+      end
+
+      # Records an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+    end
+  end
+end

data/lib/tap/generator/preview.rb

@@ -0,0 +1,69 @@
+require 'stringio'
+
+module Tap
+  module Generator
+    
+    # Preview is a testing module designed so that process will return an array
+    # of relative paths for the created files/directories (which are easy
+    # to specify in a test).  Preview also collects the content of created files
+    # to be tested as needed.
+    #
+    #   class Sample < Tap::Generator::Base
+    #     def manifest(m)
+    #       dir = path('dir')
+    #
+    #       m.directory dir
+    #       m.file(File.join(dir, 'file.txt')) {|io| io << "content"}
+    #     end
+    #   end
+    #
+    # These assertions will pass:
+    #
+    #   s = Sample.new.extend Preview
+    #   assert_equal %w{
+    #     dir
+    #     dir/file.txt
+    #   }, s.process
+    #
+    #   assert_equal "content", s.preview['dir/file.txt']
+    #
+    # Note that relative paths are relative to destination_root.
+    module Preview
+      
+      # A hash of (relative_path, content) pairs representing
+      # content built to files.
+      attr_accessor :preview
+      
+      def self.extended(base) # :nodoc:
+        base.instance_variable_set(:@preview, {})
+      end
+      
+      # Returns the path of path, relative to destination_root.  If path
+      # is destination_root, '.' will be returned.
+      def relative_path(path)
+        path = Root::Utils.relative_path(destination_root, path, destination_root) || path
+        path.empty? ? "." : path
+      end
+      
+      # Returns the relative path of the target.
+      def directory(target, options={})
+        relative_path(target)
+      end
+      
+      # Returns the relative path of the target.  If a block is given, 
+      # the block will be called with a StringIO and the results stored
+      # in builds.
+      def file(target, options={})
+        target = relative_path(target)
+        
+        if block_given?
+          io = StringIO.new
+          yield(io)
+          preview[target] = io.string
+        end
+        
+        target
+      end
+    end
+  end
+end

data/templates/tap/generator/generators/command/command.erb

@@ -0,0 +1,31 @@
+# tap <%= command_name %> {options} ARGS...
+#
+# The default command simply prints the input arguments 
+# and application information, then exits.
+#
+
+env = Tap::Env.instance
+app = Tap::App.new
+
+#
+# handle options
+#
+
+ConfigParser.new do |opts|
+  opts.separator ""
+  opts.separator "options:"
+
+  opts.on("-h", "--help", "Show this message") do
+    puts Lazydoc.usage(__FILE__)
+    puts opts
+    exit
+  end
+  
+end.parse!(ARGV)
+
+#
+# add your script code here
+#
+
+puts "Received: #{ARGV.join(', ')}"
+puts app.info

data/templates/tap/generator/generators/generator/task.erb

@@ -0,0 +1,29 @@
+require 'tap/generator/base'
+
+<% redirect do |target| %># <%= const.const_name %>::generator <replace with manifest summary>
+# <replace with command line description>
+
+# <%= const.name %> Documentation
+class <%= const.name %> < Tap::Generator::Base
+
+  config :key, 'value'           # a sample config
+  
+  # The generator will receive the inputs on the command line, and
+  # m, a Manifest object that records the actions of this method.
+  def manifest(m, *inputs)
+
+    # make a directory
+    # m.directory path
+
+    # make a file
+    # m.file path do |file|
+    #   file << content
+    # end
+
+    # template a file in the templates directory using ERB.
+    # The last argument defines a hash of local variables
+    # for use in the template (here config is used).
+    m.template "<%= const.const_name.underscore %>_file.txt", "template_file.erb", config.to_hash
+  end
+  
+end <% module_nest(const.nesting, '  ') { target } end %>

data/templates/tap/generator/generators/generator/test.erb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
+require '<%= const.path %>'
+require 'tap/generator/preview.rb'
+
+class <%= const.name %>Test < Test::Unit::TestCase
+
+  # Preview fakes out a generator for testing
+  Preview = Tap::Generator::Preview
+  
+  acts_as_tap_test 
+  
+  def test_<%= const.basename %>
+    g = <%= const.const_name %>.new.extend Preview
+    
+    # check the files and directories
+    assert_equal %w{
+      <%= const.const_name.underscore %>_file.txt
+    }, g.process
+    
+    # check the content as necessary
+    assert_equal %q{
+# A sample template file.
+key: value
+}, "\n" + g.preview['<%= const.const_name.underscore %>_file.txt']
+  end
+end

data/templates/tap/generator/generators/root/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) <%= Time.now.year %>, <copyright holders>
+
+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/templates/tap/generator/generators/root/README

@@ -0,0 +1,14 @@
+= <%= project_name.capitalize %>
+
+== Description
+
+== Usage
+
+== Installation
+
+== Info
+<% if license %>
+
+Copyright (c) <%= Time.now.year %>, <copyright holders>
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]
+<% end %>

data/templates/tap/generator/generators/root/Rakefile

@@ -0,0 +1,85 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+#
+# Gem specification
+#
+
+def gemspec
+  data = File.read('<%= project_name %>.gemspec')
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  spec
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Prints the gemspec manifest.'
+task :print_manifest do
+  # collect files from the gemspec, labeling 
+  # with true or false corresponding to the
+  # file existing or not
+  files = gemspec.files.inject({}) do |files, file|
+    files[File.expand_path(file)] = [File.exists?(file), file]
+    files
+  end
+  
+  # gather non-rdoc/pkg files for the project
+  # and add to the files list if they are not
+  # included already (marking by the absence
+  # of a label)
+  Dir.glob("**/*").each do |file|
+    next if file =~ /^(rdoc|pkg|backup)/ || File.directory?(file)
+    
+    path = File.expand_path(file)
+    files[path] = ["", file] unless files.has_key?(path)
+  end
+  
+  # sort and output the results
+  files.values.sort_by {|exists, file| file }.each do |entry| 
+    puts "%-5s %s" % entry
+  end
+end
+
+#
+# Documentation tasks
+#
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  spec = gemspec
+  
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options.concat(spec.rdoc_options)
+  rdoc.rdoc_files.include( spec.extra_rdoc_files )
+  
+  files = spec.files.select {|file| file =~ /^lib.*\.rb$/}
+  rdoc.rdoc_files.include( files )
+  
+  # Using CDoc to template your RDoc will result in configurations being
+  # listed with documentation in a subsection following attributes.  Not
+  # necessary, but nice.
+  require 'cdoc'
+  rdoc.template = 'cdoc/cdoc_html_template' 
+  rdoc.options << '--fmt' << 'cdoc'
+end
+
+#
+# Test tasks
+#
+
+desc 'Default: Run tests.'
+task :default => :test
+
+desc 'Run tests.'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = Dir.glob( File.join('test', ENV['pattern'] || '**/*_test.rb') )
+  t.ruby_opts = ['-rubygems']
+  t.verbose = true
+  t.warning = true
+end
+

data/templates/tap/generator/generators/root/Rapfile

@@ -0,0 +1,11 @@
+require 'tap/declarations'
+
+module <%= project_name.camelize %>
+  extend Rap::Declarations
+  
+  # ::desc your basic goodnight moon task
+  # Says goodnight with a configurable message.
+  task(:goodnight, :obj, :message => 'goodnight') do |task, args|
+    puts "#{task.message} #{args.obj}"
+  end
+end

data/templates/tap/generator/generators/root/gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = "<%= project_name %>"
+  s.version = "0.0.1"
+  s.author = "<%= name %>"
+  s.email = "<%= email %>"
+  s.homepage = "<%= homepage %>"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "<%= summary %>"
+  s.require_path = "lib"
+  s.rubyforge_project = "<%= rubyforge_project %>"
+  s.add_dependency("tap", "= <%= Tap::VERSION %>")
+  s.add_development_dependency("tap-test")
+  s.has_rdoc = true
+  s.rdoc_options.concat %W{--main README -S -N --title <%= project_name.capitalize %>}
+  
+  # list extra rdoc files here.
+  s.extra_rdoc_files = %W{
+<%= history ? "    History\n" : '' %>
+    README
+<%= license ? "    MIT-LICENSE\n" : '' %>
+  }
+  
+  # list the files you want to include here. you can
+  # check this manifest using 'rap print_manifest'
+  s.files = %W{
+    tap.yml
+  }
+end

data/templates/tap/generator/generators/root/test/tap_test_helper.rb

@@ -0,0 +1 @@
+require 'tap/test/unit'

data/templates/tap/generator/generators/task/task.erb

@@ -0,0 +1,16 @@
+require 'tap/task'
+
+<% redirect do |target| %># <%= const.const_name %>::manifest <replace with manifest summary>
+# <replace with command line description>
+
+# <%= const.name %> Documentation
+class <%= const.name %> < Tap::Task
+
+  # <config file documentation>
+  config :message, 'goodnight'           # a sample config
+  
+  def process(name)
+    log message, name
+    "#{message} #{name}"
+  end
+end <% module_nest(const.nesting, '  ') { target } end %>

data/templates/tap/generator/generators/task/test.erb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
+require '<%= const.path %>'
+
+class <%= const.name %>Test < Test::Unit::TestCase
+  acts_as_tap_test 
+  
+  def test_<%= const.basename %>
+    task = <%= const.const_name %>.new :message => "goodnight"
+    
+    # a simple test
+    assert_equal({:message  => 'goodnight'}, task.config)
+    assert_equal "goodnight moon", task.process("moon")
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: tap-gen
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-25 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.17.0
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History
+- README
+- MIT-LICENSE
+files: 
+- cmd/destroy.rb
+- cmd/generate.rb
+- lib/tap/generator/arguments.rb
+- lib/tap/generator/base.rb
+- lib/tap/generator/destroy.rb
+- lib/tap/generator/exe.rb
+- lib/tap/generator/generate.rb
+- lib/tap/generator/generators/command.rb
+- lib/tap/generator/generators/config.rb
+- lib/tap/generator/generators/generator.rb
+- lib/tap/generator/generators/root.rb
+- lib/tap/generator/generators/task.rb
+- lib/tap/generator/manifest.rb
+- lib/tap/generator/preview.rb
+- tap.yml
+- templates/tap/generator/generators/command/command.erb
+- templates/tap/generator/generators/generator/task.erb
+- templates/tap/generator/generators/generator/test.erb
+- templates/tap/generator/generators/root/MIT-LICENSE
+- templates/tap/generator/generators/root/README
+- templates/tap/generator/generators/root/Rakefile
+- templates/tap/generator/generators/root/Rapfile
+- templates/tap/generator/generators/root/gemspec
+- templates/tap/generator/generators/root/test/tap_test_helper.rb
+- templates/tap/generator/generators/task/task.erb
+- templates/tap/generator/generators/task/test.erb
+- History
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://tap.rubyforge.org/tap-gen
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- -S
+- -N
+- --title
+- Tap-Generator
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Generators for Tap
+test_files: []
+