tap 0.9.1 → 0.10.0

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

@@ -1,17 +1,21 @@
 module Tap::Generator::Generators
-  class CommandGenerator < Rails::Generator::NamedBase # :nodoc:
-    def initialize(*args)
-      super(*args)    
-      @destination_root  = Tap::App.instance[:root]
-      @app = Tap::App.instance
-  	end
-
-    def manifest
-      record do |m|
-        command_path = @app.relative_filepath(:root, @app[:cmd])
-        m.directory class_path.empty? ? command_path : File.join(command_path, class_path)
-        m.template "command.erb", File.join(command_path, class_name.underscore + ".rb")
+  
+  # :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 CommandGenerator < Tap::Generator::Base
+    
+    def manifest(m, command_name)
+      m.directory app['cmd']
+      
+      template_files do |source, target|
+        m.template app.filepath('cmd', "#{command_name}.rb"), source, :command_name => command_name
       end
     end
+    
   end
 end

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

@@ -1,34 +1,28 @@
-# = Usage
-# tap <%= file_name %> {options} ARGS...
+# tap <%= command_name %> {options} ARGS...
 #
-# = Description
 # The default command simply prints the input arguments 
 # and application information, then exits.
 #
 
-require 'tap'
-
-app = Tap::App.instance   
+env = Tap::Env.instance
+app = Tap::App.instance
 
 #
 # handle options
 #
 
-opts = [
-  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."],
-  ['--debug', nil, GetoptLong::NO_ARGUMENT, "Specifies debug mode."]]
-  
-Tap::Support::CommandLine.handle_options(*opts) do |opt, value| 
-  case opt
-  when '--help'
-    puts Tap::Support::CommandLine.command_help(__FILE__, opts)
-    exit
-    
-  when '--debug'
-    app.options.debug = true
+OptionParser.new do |opts|
+  opts.separator ""
+  opts.separator "options:"
 
+  opts.on("-h", "--help", "Show this message") do
+    opts.banner = Tap::Support::CommandLine.usage(__FILE__)
+    puts opts
+    exit
   end
-end
+  
+end.parse!(ARGV)
+
 
 #
 # add your script code here

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

@@ -1,33 +1,24 @@
 module Tap::Generator::Generators
-  class ConfigGenerator < Rails::Generator::NamedBase # :nodoc:
-    attr_accessor :formatted_yaml
+  
+  # :startdoc::generator a config file for a task
+  # 
+  # Generates a new config file for a task.  The configurations, defaults, 
+  # and documentation is determined from the task source file.
+  class ConfigGenerator < Tap::Generator::Base
+    
+    config :doc, true, &c.switch  # include documentation in the config
+    
+    def env
+      Tap::Env.instance
+    end
 
-    def initialize(argv, options)
-      @app = Tap::App.instance
-      name, @version = @app.deversion(argv[0])
-      argv[0] = name
+    def manifest(m, name, config_name=name)
+      const = env.search(:tasks, name) or raise "unknown task: #{name}"
+      task_class = const.constantize or raise "unknown task: #{name}"
       
-      super(argv, options)    
-      
-      @destination_root  = Tap::App.instance[:root]
-  	end
-
-    def manifest
-      record do |m|
-        task = @app.task(class_name)
-        self.formatted_yaml = task.class.configurations.format_yaml
-    
-        config_path = @app.relative_filepath(:root, @app[:config])
-        
-        if @version == nil
-          # then get the next increment?
-          # Tap::App.vglob(File.join(config_path, class_name.underscore + '.yml'))
-        end
-        version = @version == nil ? '' : "-#{@version}"
-        
-        m.directory File.join(config_path, class_path)
-        m.template "config.erb", File.join(config_path, class_name.underscore + "#{version}.yml")
-        
+      m.directory app['config']
+      m.file app.filepath('config', config_name + '.yml') do |file|
+        task_class.configurations.format_str((doc ? :doc : :nodoc), file)
       end
     end
     

data/lib/tap/generator/generators/config/templates/doc.erb

@@ -0,0 +1,12 @@
+###############################################################################
+# <%= receiver %> configuration<%= configurations.length > 1 ? 's' : '' %>
+###############################################################################
+<% configurations.each do |key, config| %>
+
+<% Comment.wrap(config.desc.to_s.split(/\r?\n/), 50, 2).each do |line|  %>
+# <%=  line %>
+<% end %>
+<%= config.default == nil ? '#' : '' %><%= yamlize({key.to_s => config.default}) %>
+
+<% end %>
+

data/lib/tap/generator/generators/config/templates/nodoc.erb

@@ -0,0 +1,8 @@
+###############################################################################
+# <%= receiver %> configuration<%= configurations.length > 1 ? 's' : '' %>
+###############################################################################
+<% configurations.each do |key, config| %>
+<%= config.default == nil ? '#' : ''%><%= yamlize({key.to_s => config.default}) %>
+
+<% end %>
+

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

@@ -1,21 +1,26 @@
 require 'tap/generator/generators/task/task_generator'
 
 module Tap::Generator::Generators
-  class FileTaskGenerator < TaskGenerator # :nodoc:
+  
+  # :startdoc::generator a file_task and test
+  #
+  # Generates a new Tap::FileTask and associated test files.
+  class FileTaskGenerator < TaskGenerator
     
-    def task_manifest(m)
-      return unless options[:test]
+    def manifest(m, const_name)
+      const = super
       
-      test_path = @app.relative_filepath(:root, @app[:test])
-      m.directory File.join(test_path, class_name.underscore)
+      if test
+        test_dir = app.filepath('test', const.path, "test_#{const.basename}")
         
-      method_test_path = File.join(test_path, class_name.underscore, "test_#{file_name.underscore}")
-      m.directory method_test_path
-      m.directory File.join(method_test_path, "input")
-      m.directory File.join(method_test_path, "expected")
+        m.directories test_dir, %W{
+          input
+          expected
+        }
         
-      m.file "file.txt", File.join(method_test_path, "input", "file.txt")
-      m.file "file.yml", File.join(method_test_path, "expected", "file.yml")
+        m.template File.join(test_dir, 'input/file.txt'), "file.txt", :const => const, :test_dir => test_dir
+        m.template File.join(test_dir, 'expected/result.yml'), "result.yml", :const => const, :test_dir => test_dir
+      end
     end
     
   end

data/lib/tap/generator/generators/file_task/templates/file.txt

@@ -1,2 +1,11 @@
-Line One
-Line Two
+absquatulate - verb: This amusing, vivid, and expressive word is a bit of a jocular, contrived slang.  To absquatulate is to decamp, to scram, to take off in a hell of a hurry like a fugitive heading into the woods.
+
+algorism - noun: This is the name of the Arabic numbering system, using the figures 1 to 9 plus the zero.  The derivation is from Middle Latin algorismus, from the Arabic al (the) plus Khuwarizmi, the surname of a ninth-century Arabic mathematician.  Algorithm is sometimes used as a synonym, but is also used to designate a set of rules for the solution of a mathematical problem in a finite number of steps.  These words are entirely unrelated to algolagnia, with its very different meaning and derivation.
+
+defenestration - verb: Defenestration is the act of throwing someone (yes, someone!) or something out of a window.  To defenestrate a person or thing is to engage in this activity - a strange one indeed, since these words are more commonly applied to situations where what is thrown out of the window is a person, rather than a thing.  It is surprising, in view of what must be the infrequency of this type of activity, that there exists word for it, but then, there exists a word for just about everything.
+
+macaronic - adj: This peculiar word, a jocular concoction from macaroni, is applied, in a narrow sense, to language characterized by a mixture of Latin and non-Latin words, or by non-Latin words given phony Latin endings; in a broader sense, to prose or verse composed of any mixture of languages; in its broadest sense, to anything mixed or jumbled.
+
+trumpery - noun: Trumpery is worthless stuff.  
+
+usufruct - noun: Usufruct is a term used in law primarily, to denote one's right to enjoy the use and benefits flowing from the use of another's property, without the ownership of it and without the right to harm or waste or destroy it.

data/lib/tap/generator/generators/file_task/templates/result.yml

@@ -0,0 +1,6 @@
+--- 
+- 111
+- 155
+- 123
+- 125
+- 56

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

@@ -1,40 +1,33 @@
-# == Description
-# Replace with a description.  The default task reads
-# in the lines of a text file and dumps them as YAML
-# into a yaml file.
-# === Usage
-# Replace with usage instructions
+<% redirect do |target| %># <%= const.name %>::manifest <replace with manifest summary>
+# <replace with command line description>
+
+# <%= const.const_name %> Documentation
+# This example FileTask counts the specified letters
+# in a source file and writes the counts to a target
+# file as YAML.
 #
-class <%= class_name_without_nesting %> < Tap::FileTask
-  # use config to set task configurations
-  # configs have accessors by default
-  
-  config :key, 'value'           # a sample config
-  
-  # process defines what the task does; use the
-  # same number of inputs to enque the task
-  # as specified here
-  def process(filepath)
+class <%= const.const_name %> < Tap::FileTask
+
+  # <config file documentation>
+  config :letters, ['a','e','i','o','u'], &c.array  # a list of letters to count
 
-    # infer an output filepath relative to the :data directory, 
-    # (this is convenient for testing) while changing the 
-    # basename of filepath to 'yml'.  See FileTask#filepath 
-    # for filepaths based on the task name.
-    target = app.filepath(:data, basename(filepath, '.yml') )
+  def process(source, target)
 
-    # prepare ensures the parent directory for 
-    # output exists, and that output does not; 
-    # any existing file is backed up and reverts
-    # in the event of an error
+    # prepare ensures the parent directory for target
+    # exists and, if necessary, backs up the existing
+    # target file (which is restored on error)
     prepare(target) 
-    
+
     # now perform the task...
-    array = File.read(filepath).split(/\r?\n/)
+    str = File.read(source)
+    letter_count = letters.collect do |letter|
+      str.count(letter)
+    end
+
     File.open(target, "wb") do |file|
-      file << array.to_yaml
+      file << letter_count.to_yaml
     end
-    
+
     target
   end
-  
-end
+end <% module_nest(const.nesting, '  ') { target } end %>

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

@@ -1,31 +1,27 @@
-require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
-require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
+require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
+require '<%= const.path %>'
 
-class <%= class_name %>Test < Test::Unit::TestCase
+class <%= const.name %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
-  def test_<%= file_name.underscore %>
-    # assert_expected_result_files provides a list of the
-    # files in '<%= class_name_without_nesting.underscore %>/test_<%= file_name.underscore %>/input'
-    # and expects that the block makes a list of output
-    # files in '<%= class_name_without_nesting.underscore %>/test_<%= file_name.underscore %>/output'
-    #
-    # These outputs are compared by content with the 
-    # files in '<%= class_name_without_nesting.underscore %>/test_<%= file_name.underscore %>/expected'
-    # 
-    # The output directory is cleaned up by default.  To 
-    # preserve it, set the KEEP_OUTPUTS env variable:
-    #
+  def test_<%= const.basename %>
+    # Use assert_files to test file transform tasks.  The block  
+    # recieves the method input files and compares the results 
+    # to the method expected files.
+  
+    # Generated files are often placed in method output, as it
+    # is cleaned up each test.  To keep output files, set the 
+    # KEEP_OUTPUTS variable:
     #   % rake test keep_outputs=true
-    
-    t = <%= class_name %>.new 
+  
+    t = <%= const.name %>.new 
     assert_files do |input_files|
-      input_files.each {|file| t.enq(file)}
-      
-      with_config :directories => {:data => 'output'} do 
-        app.run
+      input_files.each do |source|
+        target = method_filepath(:output, 'result.yml') 
+        t.enq(source, target)
       end
-      
+    
+      app.run
       app.results(t)
     end
   end

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

@@ -1,41 +1,55 @@
 require 'tap/root'
 
 module Tap::Generator::Generators
-  class RootGenerator < Rails::Generator::NamedBase # :nodoc:
-    def initialize(*args)
-      super(*args)   
-      Tap::App.instance.root = File.join(Tap::App.instance[:root], class_path, file_name)
-      @destination_root  = Tap::App.instance[:root]
-  	end
-
-    def manifest
-      record do |m|
-        # directories
-        m.directory "lib"
-        #m.directory "config"
-        m.directory "test"
-
-        # remove these -- they will be created from
-        # a server generator in the future
-        #m.directory "server/config"
-        #m.directory "server/test"
-        #m.directory "server/lib/tasks"
+  
+  # :startdoc::generator a basic tap directory structure
+  #
+  # Generates a tap root directory structure:
+  #
+  #   root
+  #   |- Rakefile
+  #   |- lib
+  #   |- sample.gemspec
+  #   |- tap.yml
+  #   |- tapfile.rb
+  #   `- test
+  #       |- tap_test_helper.rb
+  #       |- tap_test_suite.rb
+  #       `- tapfile_test.rb
+  #
+  class RootGenerator < Tap::Generator::Base
     
-        # files
-        template_dir = File.dirname(__FILE__) + "/templates"
-        Dir.glob(template_dir + "/**/*").each do |fname|
-          next if File.directory?(fname)
-          
-          # skip server files for now... later 
-          # the files will simply be removed
-          next if fname =~ /server/
-          next if fname =~ /config/
-          next if fname =~ /process_tap_request/
+    # ::args ROOT, PROJECT_NAME=basename(ROOT)
+    def manifest(m, root, project_name=File.basename(root))
+      project_name = 'project' if project_name == '.'
+      r = Tap::Root.new(root)
       
-          fname = Tap::Root.relative_filepath(template_dir, fname)
-          m.template fname, fname
+      m.directory r.root
+      m.directory r['lib']
+      
+      template_files do |source, target|
+        case
+        when File.directory?(source)
+          m.directory r[target]
+        when target == 'gemspec'
+          m.template r[project_name + '.gemspec'], source, :project_name => project_name
+        when target == 'tapfile'
+          m.template r['tapfile.rb'], source, :project_name => project_name
+        else
+          m.template r[target], source, :project_name => project_name
         end
       end
+      
+      # m.file(r['tap.yml']) do |file|
+      #  Tap::App.configurations.format_str(:doc, file) do |templater|
+      #    next unless templater.receiver == Tap::Root
+      #     
+      #    templater.configurations.each do |(key, config)| 
+      #      config.default = nil if key.to_s == 'root'
+      #    end
+      #  end
+      #  Tap::Env.configurations.format_str(:doc, file)
+      # end
     end
   end
 end

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

@@ -3,61 +3,84 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
 
-# tasks
-desc 'Default: Run tests.'
-task :default => :test
+require 'tap/constants'
+require 'tap/patches/rake/testtask.rb'
 
-desc 'Run tests.'
-Rake::TestTask.new(:test) do |t|
+#
+# 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
   
-  # Here the current load paths are used to define the load
-  # paths in the test.  This is convenient for development 
-  # but doesn't have to be here.  Note the patch is to
-  # allow spaces in the lib paths, as you find on Windows.
-  require 'tap/patches/rake/testtask'
-  t.libs = $: + ['lib']
+  # 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)/ || File.directory?(file)
+    
+    path = File.expand_path(file)
+    files[path] = ["", file] unless files.has_key?(path)
+  end
   
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-  t.warning = true
+  # 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|
-  # options to specify TDoc
-  require 'tap/support/tdoc'
-  rdoc.template = 'tap/support/tdoc/tdoc_html_template' 
-  rdoc.options << '--fmt' << 'tdoc'
+  spec = gemspec
   
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = '<%= file_name %>'
-  rdoc.template = 'tap/support/tdoc/tdoc_html_template' 
+  rdoc.title    = '<%= project_name %>'
   rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('ReadMe.txt')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include( spec.extra_rdoc_files )
+  rdoc.rdoc_files.include( spec.files.select {|file| file =~ /^lib.*\.rb$/} )
+  
+  # Using Tdoc to template your Rdoc will result in configurations being
+  # listed with documentation in a subsection following attributes.  Not
+  # necessary, but nice.
+  require 'tap/support/tdoc'
+  rdoc.template = 'tap/support/tdoc/tdoc_html_template' 
+  rdoc.options << '--fmt' << 'tdoc'
 end
 
 #
-# Gem specification
+# Test tasks
 #
 
-spec = Gem::Specification.new do |s|
-  s.name = "<%= file_name %>"
-  s.version = "0.0.1"
-  s.author = "Your Name Here"
-  #s.email = "your.email@pubfactory.edu"
-  #s.homepage = "http://rubyforge.org/projects/gemname/"
-  s.platform = Gem::Platform::RUBY
-  s.summary = "Add Description"
-  s.files = Dir.glob("{test,lib}/**/*") + ["Rakefile", "ReadMe.txt"]
-  s.require_path = "lib"
-  s.test_file = "test/tap_test_suite.rb"
-  
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["ReadMe.txt"]
-  s.add_dependency("tap", ">= <%= Tap::VERSION %>")
+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.verbose = true
+  t.warning = true
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true
-end