tap 0.9.1 → 0.10.0

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

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name = "<%= project_name %>"
+  s.version = "0.0.1"
+  #s.author = "Your Name Here"
+  #s.email = "your.email@pubfactory.edu"
+  #s.homepage = "http://rubyforge.org/projects/<%= project_name %>/"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "<%= project_name %> task library"
+  s.require_path = "lib"
+  s.test_file = "test/tap_test_suite.rb"
+  #s.rubyforge_project = "<%= project_name %>"
+  #s.has_rdoc = true
+  s.add_dependency("tap", "~> <%= Tap::VERSION %>")
+  
+  # list extra rdoc files like README here.
+  s.extra_rdoc_files = %W{
+  }
+  
+  # list the files you want to include here. you can
+  # check this manifest using 'rake :print_manifest'
+  s.files = %W{
+    tapfile.rb
+    test/tap_test_helper.rb
+    test/tap_test_suite.rb
+    test/tapfile_test.rb
+  }
+end

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

@@ -0,0 +1,8 @@
+require 'tap'
+
+# Goodnight::manifest your basic goodnight moon task
+# Prints the input with a configurable message.
+Tap.task('goodnight', :message => 'goodnight') do |task, name|
+   task.log task.message, name
+   "#{task.message} #{name}"
+end

data/lib/tap/generator/generators/root/templates/test/tap_test_suite.rb

@@ -1,5 +1,5 @@
 $:.unshift File.join(File.dirname(__FILE__), '../lib')
 
 # runs all subsets (see Tap::Test::SubsetMethods)
-ENV["ALL"] = true 
+ENV["ALL"] = "true"
 Dir.glob("./**/*_test.rb").each {|test| require test}

data/lib/tap/generator/generators/root/templates/test/tapfile_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/tap_test_helper.rb'
+require File.dirname(__FILE__) + '/../tapfile.rb'
+
+class TapfileTest < Test::Unit::TestCase
+  acts_as_tap_test
+  
+  def test_goodnight
+    task = Goodnight.new :message => "goodnight"
+    
+    # a simple test
+    assert_equal({:message  => 'goodnight'}, task.config)
+    assert_equal "goodnight moon", task.process("moon")
+  end
+  
+end

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

@@ -1,34 +1,27 @@
 module Tap::Generator::Generators
-  class TaskGenerator < 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|
-        lib_path = @app.relative_filepath(:root, @app[:lib])
-        m.directory File.join(lib_path, class_path)
-        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb"), :class_nesting => class_nesting
-        
-        if options[:test]
-          test_path = @app.relative_filepath(:root, @app[:test])
-          m.directory File.join(test_path, class_path)
-          m.template "test.erb", File.join(test_path, class_name.underscore + "_test.rb")
-        end
-        
-        task_manifest(m)
+  
+  # :startdoc::generator a task and test
+  #
+  # Generates a new Tap::Task and an associated test file.
+  class TaskGenerator < Tap::Generator::Base
+    
+    config :test, true, &c.switch  # Generates the task without test files.
+    
+    def manifest(m, const_name)
+      const = Constant.new(const_name.camelize)
+      
+      task_path = app.filepath('lib', "#{const.path}.rb")
+      m.directory File.dirname(task_path)
+      m.template task_path, "task.erb", :const => const
+          
+      if test
+        test_path = app.filepath('test', "#{const.path}_test.rb")
+        m.directory File.dirname(test_path)
+        m.template test_path, "test.erb", :const => const
       end
+      
+      const
     end
-    
-    def task_manifest(m)
-    end
-    
-    def add_options!(opt)
-      options[:test] = true
-      opt.on(nil, '--[no-]test', 'Generates the task without test files.') { |value| options[:test] = value }
-    end
 
   end
 end

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

@@ -1,24 +1,14 @@
-# == Description
-# Replace with a description.  The default task simply 
-# demonstrates the use of a config and logging.  
-# === Usage
-# Replace with usage instructions
-#
-class <%= class_name_without_nesting %> < Tap::Task
-  # 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(input)
-    # use log to record information
-    result = "#{input} was processed with #{key}"
-    log self.name, result
-  
-    result
+<% redirect do |target| %># <%= const.name %>::manifest <replace with manifest summary>
+# <replace with command line description>
+
+# <%= const.const_name %> Documentation
+class <%= const.const_name %> < Tap::Task
+
+  # <config file documentation>
+  config :message, 'goodnight'           # a sample config
+  
+  def process(name)
+    log message, name
+    "#{message} #{name}"
   end
-  
-end
+end <% module_nest(const.nesting, '  ') { target } end %>

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

@@ -1,24 +1,21 @@
-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 %>
-    t = <%= class_name %>.new nil, :key => 'value'
+  def test_<%= const.basename %>
+    task = <%= const.name %>.new :message => "goodnight"
     
-    # specify application options
-    with_options(:quiet => true, :debug => true) do  
-      
-      # run the task with some inputs
-      t.enq("one")
-      app.run
-      
-      # check the configuration and outputs
-      assert_equal({:key  => 'value'}, t.config)
-      assert_audit_equal ExpAudit[[nil, "one"], [t, "one was processed with value"]], app._results(t).first
-
-    end
+    # a simple test
+    assert_equal({:message  => 'goodnight'}, task.config)
+    assert_equal "goodnight moon", task.process("moon")
+    
+    # a more complex test
+    task.enq("moon")
+    app.run
+    
+    assert_equal ["goodnight moon"], app.results(task)
+    assert_audit_equal ExpAudit[[nil, "moon"], [task, "goodnight moon"]], app._results(task)[0]
   end
-  
 end

data/lib/tap/generator/manifest.rb

@@ -0,0 +1,14 @@
+module Tap
+  module Generator
+    class Manifest
+      def initialize(actions)
+        @actions = actions
+      end
+
+      # Record an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+    end
+  end
+end

data/lib/tap/root.rb

@@ -1,4 +1,5 @@
 require 'tap/support/versions'
+require 'tap/support/configurable'
 autoload(:FileUtils, 'fileutils')
 
 module Tap
@@ -62,8 +63,8 @@ module Tap
       include Support::Versions
       
       # Returns the filepath of path relative to dir.  Both dir and path are
-      # expanded before the relative filepath is determined.  An error is 
-      # raised if the path is not relative to dir.
+      # expanded before the relative filepath is determined.  Returns nil if 
+      # the path is not relative to dir.
       #
       #   Root.relative_filepath('dir', "dir/path/to/file.txt")  # => "path/to/file.txt"
       #
@@ -71,9 +72,7 @@ module Tap
         expanded_dir = File.expand_path(dir, dir_string)
         expanded_path = File.expand_path(path, dir_string)
   
-        unless expanded_path.index(expanded_dir) == 0
-          raise "\n#{expanded_path}\nis not relative to:\n#{expanded_dir}"
-        end
+        return nil unless expanded_path.index(expanded_dir) == 0
       
         # use dir.length + 1 to remove a leading '/'.   If dir.length + 1 >= expanded.length 
         # as in: relative_filepath('/path', '/path') then the first arg returns nil, and an 
@@ -101,6 +100,15 @@ module Tap
         end.flatten.uniq
       end
       
+      # Path suffix glob.  Globs along the base paths for 
+      # paths that match the specified suffix pattern.
+      def sglob(suffix_pattern, *base_paths)
+        base_paths.collect do |base|
+          base = File.expand_path(base)
+          Dir.glob(File.join(base, suffix_pattern))
+        end.flatten.uniq
+      end
+      
       # Executes the block in the specified directory.  Makes the directory, if
       # necessary when mkdir is specified.  Otherwise, indir raises an error 
       # for non-existant directories, as well as non-directory inputs.
@@ -109,7 +117,7 @@ module Tap
           if !File.exists?(dir) && mkdir
             FileUtils.mkdir_p(dir)
           else
-            raise "non a directory: #{dir}"
+            raise "not a directory: #{dir}"
           end
         end
 
@@ -160,15 +168,242 @@ module Tap
           nil
         end
       end
+      
+      # Minimizes a set of paths to the set of shortest basepaths that unqiuely 
+      # identify the paths.  The path extension and versions are removed from
+      # the basepath if possible.  For example:
+      #
+      #   Tap::Root.minimize ['path/to/a.rb', 'path/to/b.rb']
+      #   # => ['a', 'b']
+      #
+      #   Tap::Root.minimize ['path/to/a-0.1.0.rb', 'path/to/b-0.1.0.rb']
+      #   # => ['a', 'b']
+      #
+      #   Tap::Root.minimize ['path/to/file.rb', 'path/to/file.txt']
+      #   # => ['file.rb', 'file.txt']
+      #
+      #   Tap::Root.minimize ['path-0.1/to/file.rb', 'path-0.2/to/file.rb']
+      #   # => ['path-0.1/to/file', 'path-0.2/to/file']
+      #
+      # Minimized paths that carry their extension will always carry
+      # their version as well, but the converse is not true; paths
+      # can be minimized to carry just the version and not the path
+      # extension.
+      #
+      #   Tap::Root.minimize ['path/to/a-0.1.0.rb', 'path/to/a-0.1.0.txt']
+      #   # => ['a-0.1.0.rb', 'a-0.1.0.txt']
+      #
+      #   Tap::Root.minimize ['path/to/a-0.1.0.rb', 'path/to/a-0.2.0.rb']
+      #   # => ['a-0.1.0', 'a-0.2.0']
+      #
+      # If a block is given, each (path, mini-path) pair will be passed
+      # to it after minimization.
+      def minimize(paths) # :yields: path, mini_path
+        unless block_given?
+          mini_paths = []
+          minimize(paths) {|p, mp| mini_paths << mp }
+          return mini_paths  
+        end
+        
+        splits = paths.uniq.collect do |path|
+          extname = File.extname(path)
+          extname = '' if extname =~ /^\.\d+$/
+          base = File.basename(path.chomp(extname))
+          version = base =~ /(-\d+(\.\d+)*)$/ ? $1 : ''
+          
+          [dirname_or_array(path), base.chomp(version), extname, version, false, path]
+        end
+
+        while !splits.empty?
+          index = 0
+          splits = splits.collect do |(dir, base, extname, version, flagged, path)|
+            index += 1
+            case
+            when !flagged && just_one?(splits, index, base)
+              
+              # found just one
+              yield(path, base)
+              nil
+            when dir.kind_of?(Array)
+              
+              # no more path segments to use, try to add
+              # back version and extname
+              if dir.empty?
+                dir << File.dirname(base)
+                base = File.basename(base)
+              end
+              
+              case
+              when !version.empty?
+                # add back version (occurs first)
+                [dir, "#{base}#{version}", extname, '', false, path]
+                
+              when !extname.empty?
+                
+                # add back extension (occurs second)
+                [dir, "#{base}#{extname}", '', version, false, path]
+              else
+                
+                # nothing more to distinguish... path is minimized (occurs third)
+                yield(path, min_join(dir[0], base))
+                nil
+              end
+            else
+
+              # shift path segment.  dirname_or_array returns an
+              # array if this is the last path segment to shift.
+              [dirname_or_array(dir), min_join(File.basename(dir), base), extname, version, false, path]
+            end
+          end.compact
+        end
+      end
+
+      # Returns true if the mini_path matches path.  Matching logic
+      # reverses that of minimize: 
+      # * a match occurs when path ends with mini_path
+      # * if mini_path doesn't specify an extension, then mini_path
+      #   must only match path up to the path extension
+      # * if mini_path doesn't specify a version, then mini_path
+      #   must only match path up to the path basename (minus the
+      #   version and extname)
+      #
+      # For example:
+      #
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'file')           # => true
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'dir/file')       # => true
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'file-0.1.0')     # => true
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'file-0.1.0.rb')  # => true
+      #
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'file.rb')        # => false
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'file-0.2.0')     # => false
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.rb', 'another')        # => false
+      #
+      # In matching, partial basenames are not allowed but partial directories
+      # are allowed.  Hence:
+      #
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.txt', 'file')          # => true
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.txt', 'ile')           # => false
+      #   Tap::Root.minimal_match?('dir/file-0.1.0.txt', 'r/file')        # => true
+      #
+      def minimal_match?(path, mini_path)
+        extname = File.extname(mini_path)
+        extname = '' if extname =~ /^\.\d+$/
+        version = mini_path =~ /(-\d+(\.\d+)*)#{extname}$/ ? $1 : ''
+   
+        match_path = case
+        when !extname.empty?
+          # force full match
+          path
+        when !version.empty?
+          # match up to version
+          path.chomp(File.extname(path))
+        else
+          # match up base
+          path.chomp(File.extname(path)).sub(/(-\d+(\.\d+)*)$/, '')
+        end
+        
+        # key ends with pattern AND basenames of each are equal... 
+        # the last check ensures that a full path segment has 
+        # been specified
+        match_path[-mini_path.length, mini_path.length] == mini_path  && File.basename(match_path) == File.basename(mini_path)
+      end
+      
+      # Returns the path segments for the given path, splitting along the path 
+      # divider.  Root paths are always represented by a string, if only an 
+      # empty string.
+      #
+      #   os          divider    example
+      #   windows     '\'        Root.split('C:\path\to\file')  # => ["C:", "path", "to", "file"]
+      #   *nix        '/'        Root.split('/path/to/file')    # => ["", "path", "to", "file"]
+      # 
+      # The path is always expanded relative to the expand_dir; so '.' and '..' are 
+      # resolved.  However, unless expand_path == true, only the segments relative
+      # to the expand_dir are returned.  
+      #
+      # On windows (note that expanding paths allows the use of slashes or backslashes):
+      #
+      #   Dir.pwd                                               # => 'C:/'
+      #   Root.split('path\to\..\.\to\file')                    # => ["C:", "path", "to", "file"]
+      #   Root.split('path/to/.././to/file', false)             # => ["path", "to", "file"]
+      #
+      # On *nix (or more generally systems with '/' roots):
+      #
+      #   Dir.pwd                                               # => '/'
+      #   Root.split('path/to/.././to/file')                    # => ["", "path", "to", "file"]
+      #   Root.split('path/to/.././to/file', false)             # => ["path", "to", "file"]
+      #
+      def split(path, expand_path=true, expand_dir=Dir.pwd)
+        path = if expand_path
+          File.expand_path(path, expand_dir)
+        else
+          # normalize the path by expanding it, then
+          # work back to the relative filepath as needed
+          expanded_dir = File.expand_path(expand_dir)
+          expanded_path = File.expand_path(path, expand_dir)
+          expanded_path.index(expanded_dir) != 0 ? expanded_path : Tap::Root.relative_filepath(expanded_dir, expanded_path)
+        end
+
+        segments = path.scan(/[^\/]+/)
+
+        # add back the root filepath as needed on *nix 
+        segments.unshift "" if path[0] == ?/
+        segments
+      end
+      
+      private
+      
+      # utility method for minimize -- joins the
+      # dir and path, preventing results like:
+      #
+      #   "./path"
+      #   "//path"
+      def min_join(dir, path) # :nodoc:
+        case dir
+        when "." then path
+        when "/" then "/#{path}"
+        else "#{dir}/#{path}"
+        end
+      end
+      
+      # utility method for minimize -- returns the 
+      # dirname of path, or an array if the dirname
+      # is effectively empty.
+      def dirname_or_array(path) # :nodoc:
+        dir = File.dirname(path)
+        case dir
+        when path, '.' then []
+        else dir
+        end
+      end
+      
+      # utility method for minimize -- determines if there 
+      # is just one of the base in splits, while flagging
+      # all matching entries.
+      def just_one?(splits, index, base) # :nodoc:
+        just_one = true
+        index.upto(splits.length-1) do |i|
+          if splits[i][1] == base
+            splits[i][4] = true
+            just_one = false
+          end
+        end
+        
+        just_one
+      end
+      
     end
   
     include Support::Versions
+    include Support::Configurable
+
+    # The root directory.
+    config_attr(:root, '.', :writer => false)
     
-    # The root directory
-    attr_reader :root
+    # A hash of (alias, relative path) pairs for aliased subdirectories.
+    config_attr(:directories, {}, :writer => false)
     
-    # A hash of (alias, relative path) pairs for aliased subdirectories
-    attr_reader :directories
+    # A hash of (alias, relative path) pairs for aliased absolute paths.
+    config_attr(:absolute_paths, {}, :reader => false, :writer => false)
     
     # A hash of (alias, expanded path) pairs for aliased subdirectories and absolute paths.
     attr_reader :paths
@@ -182,29 +417,30 @@ module Tap
     # and no aliased directories or absolute paths are specified.  
     def initialize(root=Dir.pwd, directories={}, absolute_paths={})
       assign_paths(root, directories, absolute_paths)
+      @config = self.class.configurations.instance_config(self)
     end
-  
-    # Sets the root directory.  All paths are reassigned accordingly.
+    
+    # Sets the root directory. All paths are reassigned accordingly.
     def root=(path)
       assign_paths(path, directories, absolute_paths)
     end
   
-    # Sets the directories to those provided.  'root' and :root are reserved  
+    # Sets the directories to those provided. 'root' and :root are reserved
     # and cannot be set using this method (use root= instead).
     #
-    #   r['alt']                               # => File.join(r.root, 'alt')
-    #   r.directories = {'alt' => 'dir'}
-    #   r['alt']                               # => File.join(r.root, 'dir')
+    # r['alt'] # => File.join(r.root, 'alt')
+    # r.directories = {'alt' => 'dir'}
+    # r['alt'] # => File.join(r.root, 'dir')
     def directories=(dirs)
       assign_paths(root, dirs, absolute_paths)
     end
     
-    # Sets the absolute paths to those provided. 'root' and :root are reserved  
+    # Sets the absolute paths to those provided. 'root' and :root are reserved
     # directory keys and cannot be set using this method (use root= instead).
     #
-    #   r['abs']                               # => File.join(r.root, 'abs')
-    #   r.absolute_paths = {'abs' => '/path/to/dir'}
-    #   r['abs']                               # => '/path/to/dir'
+    # r['abs'] # => File.join(r.root, 'abs')
+    # r.absolute_paths = {'abs' => '/path/to/dir'}
+    # r['abs'] # => '/path/to/dir'
     def absolute_paths=(paths)
       assign_paths(root, directories, paths)
     end
@@ -298,7 +534,10 @@ module Tap
     #  fp = r.filepath(:in, 'path/to/file.txt')    # => '/root_dir/in/path/to/file.txt'
     #  r.translate(fp, :in, :out)                  # => '/root_dir/out/path/to/file.txt'
     def translate(filepath, input_dir, output_dir)
-      filepath(output_dir, relative_filepath(input_dir, filepath))
+      unless relative_path = relative_filepath(input_dir, filepath)
+        raise "\n#{filepath}\nis not relative to:\n#{input_dir}"
+      end
+      filepath(output_dir, relative_path)
     end
   
     # Lists all files in the aliased dir matching the input patterns.  Patterns