tap 0.7.9 → 0.8.0

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

@@ -12,23 +12,28 @@ module Tap::Generator::Generators
       record do |m|
         # directories
         m.directory "lib"
-        m.directory "config"
+        #m.directory "config"
         m.directory "test"
-        m.directory "public"
-        m.directory "public/images"
-        m.directory "public/stylesheets"
-        m.directory "gemspecs"
-        m.directory "server/config"
-        m.directory "server/test"
-        m.directory "server/lib/tasks"
+
+        # 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"
     
         # 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/
       
           fname = Tap::Root.relative_filepath(template_dir, fname)
-          m.file fname, fname
+          m.template fname, fname
         end
       end
     end

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

@@ -9,17 +9,23 @@ task :default => :test
 
 desc 'Run tests.'
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = File.join('test', ENV['subset'] || '', ENV['pattern'] || '**/*_test.rb')
-  t.verbose = true
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = true
 end
 
 desc 'Generate documentation.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Local'  # should be changed
+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'
+  
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = '<%= file_name %>'
+  rdoc.template = 'tap/support/tdoc/tdoc_html_template' 
   rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('ReadMe.txt')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
@@ -27,20 +33,20 @@ end
 # Gem specification
 #
 spec = Gem::Specification.new do |s|
-	#s.name = "gemname"
+	s.name = "<%= file_name %>"
 	s.version = "0.0.1"
-	#s.author = "Your Name Here"
+	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 = "Description"
-	s.files = Dir.glob("{test,lib,docs}/**/*")
+	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"          # should be changed
+	s.test_file = "test/tap_test_suite.rb"
 	
 	s.has_rdoc = true
-	s.extra_rdoc_files = ["README"]
-	s.add_dependency("tap", ">= 0.1.0")
+	s.extra_rdoc_files = ["ReadMe.txt"]
+	s.add_dependency("tap", ">= <%= Tap::VERSION %>")
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/tap/generator/generators/root/templates/tap.yml

@@ -0,0 +1,82 @@
+######################################################
+# App Configurations:
+#
+# These are configurations that directly affect the
+# application, including the directory structure
+# options, and logging.
+#
+######################################################
+  
+# You can set an alternate root, but this is 
+# an odd and perhaps unwise thing to do
+#root:                         
+
+# Uncomment to specify aliases for directories relative to root.  
+# Access using:  app['lib']           # => root/alt_lib
+# By default:    app['lib']           # => root/lib
+#directories:                  
+  #lib: alt_lib             
+  #...
+  
+# Uncomment to specify aliases for absolute paths
+# Access using:  app['log']           # => /path/to/logs
+#absolute_paths:                  
+  #log: /path/to/logs      
+  #...
+
+# Uncomment to specify options.
+# Access using:  app.options.debug    # => true 
+#options:                      
+  #debug: true                   # full error output, increased logging
+  #quiet: true                   # supresses logging
+  #...                           # you can add your own options
+  
+# Specify logging options here.  
+#logger:
+  #device:                       # STDOUT by default
+  #level: 1                      # [DEBUG, INFO, WARN, ERROR, FATAL, ANY]
+  #datetime_format: %H:%M:%S      # Hour:Minute:Second
+
+# Map task names to task classes here.  The example causes
+# app.task('some/task_name') to intialize a Tap::FileTask 
+# with that name.  Any number of mappings can be specified.
+#map:
+#  some/task_name: Tap::FileTask
+#  CapsAreOk: Tap::Task
+
+
+######################################################
+# Script Configurations:
+#
+# These are configurations that affect the execution 
+# environment for Tap and are NOT passed to the 
+# application itself.
+#
+######################################################
+
+# Designate load paths here for automatic loading and
+# reloading of tasks through the active_support 
+# Dependencies module.  The default is 'lib'.  Paths 
+# are resolved to the aliases setup above, 
+# 'lib' => app['lib']
+#load_paths: 
+#  - 'lib'
+
+# Designate script paths for discovering and executing
+# commands.  The default is 'script'. Paths are resolved 
+# to the aliases setup above, 'script' => app['script']
+#script_paths:
+#  - 'script'
+
+# Specify gems that contain load_paths and script_paths
+# that you likewise want to be automatically loaded.
+# Specify versions directly.             
+#gems: 
+#  - gem_name
+#  - gem_with_version > 1.0.0
+
+# Specify code to execute before and after Tap executes
+#before: |
+#  puts "beginning..."
+#after: |
+#  puts "done!"

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

@@ -1,3 +1,2 @@
-require 'rubygems'
 require 'tap'
 require 'tap/test'

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

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

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

@@ -0,0 +1,17 @@
+module Tap::Generator::Generators
+  class ScriptGenerator < 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|
+        script_path = @app.relative_filepath(:root, @app[:script])
+        m.directory class_path.empty? ? script_path : File.join(script_path, class_path)
+        m.template "script.erb", File.join(script_path, class_name.underscore + ".rb")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# = Usage
+# tap <%= file_name %> {options} OTHER_ARGS...
+#
+# = Description
+# Some informative description...
+#
+# = Information
+#
+# Developer:: <your name>
+# Homepage:: <your homepage>
+# Copyright (c):: <%= Time.now.strftime("%Y") %>, <copyright holders>
+# License:: MIT-LICENSE (http://www.opensource.org/licenses/mit-license.php) <or some other license...>
+#
+require 'tap/script'
+
+app = Tap::App.instance   
+
+#
+# handle options
+#
+
+opts = [
+  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."],
+  ['--debug', nil, GetoptLong::NO_ARGUMENT, "Specifes debug mode."]]
+  
+Tap::Script.handle_options(*opts) do |opt, value| 
+  case opt
+  when '--help'
+    puts Tap::Script.usage(__FILE__, "Usage", "Description", "Information", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
+    exit
+    
+  when '--debug'
+    app.options.debug = true
+
+  end
+end
+
+#
+# add your script code here
+#

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

@@ -10,7 +10,7 @@ module Tap::Generator::Generators
       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")
+        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb"), :class_nesting => class_nesting
     
         test_path = @app.relative_filepath(:root, @app[:test])
         m.directory File.join(test_path, class_path)

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

@@ -1,21 +1,29 @@
-# == Documentation
+# == Description
+# Replace with a description.  The default task simply 
+# demonstrates the use of a config and logging.  
+# === Usage
+# Replace with usage instructions
 #
-# === Command Line Usage
-# Replace with your command line usage instructions
-#
-class <%= class_name %> < Tap::Task
-
+class <%= class_name_without_nesting %> < Tap::Task
+  # uncomment to:
+  # - pass all inputs to process at once 
+  # - define a task that takes no inputs
+  
+  #do_not_iterate
+  
+  # use config to set task configurations
+  # configs have accessors by default
+  
+  config :label, 'input'           # a label for output
+  
   def process(input)
-    # The process logic goes here.
-    
-    # You can access configurations as symbols within the config hash
-    message = "#{config[:greeting]} #{input}!"
-    
-    # Use log to record information
-    log :message, message
-    
-    # The return of process is the task output
-    message
+    # the process logic goes here.
+  
+    # use log to record information
+    log label, input
+  
+    # the return of process is the task output
+    "#{label}: #{input} was processed"
   end
   
 end

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

@@ -1,28 +1,24 @@
 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) %>'
 
-class <%= class_name %>Test < Test::Unit::TestCase
+class <%= class_name_without_nesting %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
-  def test_greeting
-    t = <%= class_name %>.new nil, :greeting => 'hello'
+  def test_<%= file_name %>
+    t = <%= class_name %>.new nil, :label => 'key'
     
+    # specify application options
     with_options(:quiet => true) do	
-      t.execute("from me", "to you")
-				
-      assert_equal({:greeting => 'hello'}, t.config)
-      assert_outputs(t => ["hello from me!", "hello to you!"])
       
-      # check the audit trail for each input
-      assert_audits(t.results, 
-        0 => [[nil, 'from me'], [t, 'hello from me!']],
-        1 => [[nil, 'to you'], [t, 'hello to you!']])
-      
-      # an alternate way of checking audits
-      check_audit(t.results[1]) do
-        'to you'._from nil
-        'hello to you!'._from t
-      end
+      # run the task with some inputs
+      app.run(t, "one", "two")
+			
+			# check the configuration and outputs
+      assert_equal({:label => 'key'}, t.config)
+      assert_outputs(t => [
+        "key: one was processed", 
+        "key: two was processed"])
+    
     end
   end
   

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

@@ -1,16 +1,16 @@
-# == Documentation
+# == Description
 #
-# === Command Line Usage
+# === Usage
 # Replace with your command line usage instructions
 #
-class <%= class_name %> < Tap::Workflow
-    protected
+class <%= class_name_without_nesting %> < Tap::Workflow
+  protected
     
-    def workflow 
-      # Define the workflow entry and exit points,
-      # as well as the workflow logic.
-      self.entry_point = Task.new
+  def workflow 
+    # Define the workflow entry and exit points,
+    # as well as the workflow logic.
+    self.entry_point = Task.new
       
-      # app.sequence(entry_point, 'another/task')
-    end
+    # app.sequence(entry_point, 'another/task')
+  end
 end

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

@@ -1,7 +1,7 @@
 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) %>'
 
-class <%= class_name %>Test < Test::Unit::TestCase
+class <%= class_name_without_nesting %>Test < Test::Unit::TestCase
   acts_as_tap_test 
   
 end

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

@@ -1,21 +1,6 @@
-module Tap::Generator::Generators
-  class WorkflowGenerator < Rails::Generator::NamedBase # :nodoc:
-    def initialize(*args)
-      super(*args)    
-      @destination_root  = Tap::App.instance[:root]
-      @app = Tap::App.instance
-  	end
+require 'tap/generator/generators/task/task_generator'
 
-    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")
-    
-        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
-    end
+module Tap::Generator::Generators
+  class WorkflowGenerator < TaskGenerator # :nodoc:
   end
 end

data/lib/tap/root.rb

@@ -1,60 +1,62 @@
-require 'fileutils'
 require 'tap/support/versions'
 
-# string.rb is required for camelizing and underscoring strings 
-# requiring just this file rather than the full gem results in 
-# noticably faster startup
-require 'active_support/core_ext/string'
-
 module Tap
   
-  # Most applications that utilize files allow the definition of a root directory, 
-  # allowing you to place the application directory wherever you like.  Root takes 
-  # this concept further, allowing you to define subdirectories, as well as manipulate 
-  # files and filepaths within these directories.  For example:
+  # Root allows you to define a root directory and alias subdirectories, so that  
+  # you can conceptualize what filepaths you need without predefining the full 
+  # filepaths.  Root also simplifies operations on filepaths.
   #
-  #  root = Root.new 'root_dir', :input => 'in', :output => 'out'
+  #  # define a root directory with aliased subdirectories
+  #  r = Root.new '/root_dir', :input => 'in', :output => 'out'
   #  
   #  # work with directories
-  #  root[:in]        # => 'root_dir/in'
-  #  root[:out]       # => 'root_dir/out'
-  #  root[:implicit]  # => 'root_dir/implicit'
+  #  r[:in]                                      # => '/root_dir/in'
+  #  r[:out]                                     # => '/root_dir/out'
+  #  r[:implicit]                                # => '/root_dir/implicit'
   #
   #  # work with filepaths
-  #  fp = root.filepath(:in, 'path/to/file.txt')  # => 'root_dir/in/path/to/file.txt'
-  #  root.relative_filepath(:in, fp)              # => 'path/to/file.txt'
-  #  root.translate(fp, :in, :out)                # => 'root_dir/out/path/to/file.txt'
+  #  fp = r.filepath(:in, 'path/to/file.txt')    # => '/root_dir/in/path/to/file.txt'
+  #  r.relative_filepath(:in, fp)                # => 'path/to/file.txt'
+  #  r.translate(fp, :in, :out)                  # => '/root_dir/out/path/to/file.txt'
   #  
   #  # version filepaths
-  #  root.version('path/to/config.yml', 1.0)          # => 'path/to/config-1.0.yml'
-  #  root.increment('path/to/config-1.0.yml', 0.1)    # => 'path/to/config-1.1.yml'
-  #  root.deversion('path/to/config-1.1.yml')         # => ['path/to/config.yml', "1.1"]
-  #  
-  #  # work with modules...
-  #  mp = root.module_filepath(:lib, 'Some::Module')  # => 'root_dir/lib/some/module.rb'
-  #  
-  #  # loading them...
-  #  Object.const_defined?(:Some)                # => false 
-  #  root.lookup_module('Some::Module')          # => Some::Module
-  #  Some.const_defined?(:Module)                # => true
+  #  r.version('path/to/config.yml', 1.0)        # => 'path/to/config-1.0.yml'
+  #  r.increment('path/to/config-1.0.yml', 0.1)  # => 'path/to/config-1.1.yml'
+  #  r.deversion('path/to/config-1.1.yml')       # => ['path/to/config.yml', "1.1"]
+  #
+  #  # absolute paths can also be aliased 
+  #  r[:abs, true] = "/absolute/path"      
+  #  r.filepath(:abs, "to", "file.txt")          # => '/absolute/path/to/file.txt'
   #
-  #  # and unloading them!
-  #  root.unload_modules                         # => ["Some::Module"]
-  #  Object.const_defined?(:Some)                # => false
+  # By default, Roots are initialized to the present working directory (Dir.pwd).
+  # As in the ':implicit' example, whenever Root needs to resolve an alias that is 
+  # not explicitly set, Root infers a path relative to the root directory.  
   #
-  # === Notes
+  # === Implementation Notes
+  #
+  # Internally Root stores expanded paths for both subdirectories and absolute paths in a 
+  # hash, 'paths', for quick lookup using the da (directory alias) keys. Expanding paths 
+  # ensures they remain constant even when the present working directory (Dir.pwd) changes.
+  #
+  # Root keeps a separate hash mapping aliases to the subdirectory paths, 'directories'.  
+  # These relative filepaths allow reassignment of the expanded paths if and when the 
+  # root directory changes.  By contrast, there is no separate data structure storing the 
+  # absolute paths. An absolute path can be distinguished from a subdirectory path by 
+  # aliases present in 'paths' but not 'directories'.
+  #
+  # These features may be important to note when subclassing Root:
+  # - root and all filepaths in 'paths' are expanded
+  # - directory aliases and subdirectory paths are stored in 'directories'
+  # - absolute paths are present in 'paths' but not in 'directories'
   #
-  # Root internally stores paths for both relative directories and absolute paths in a 
-  # hash for quick lookup using the dir keys.  Root keeps a separate hash for the 
-  # original directories used to create the paths, but this is not necessary for 
-  # absolute paths.  An absolute path can be distinguished from a directory by having
-  # an entry in paths but not directories.
   class Root  
     class << self
       include Support::Versions
       
-      # Returns the filepath of path relative to dir. If strict=true (the default) then 
-      # relative_filepath raises an error if the path is not relative to dir.
+      # Returns the filepath of path relative to dir.  Both dir and path are
+      # expanded before the relative filepath is determined.  If strict=true 
+      # (the default), then relative_filepath raises an error if the path is 
+      # not relative to dir.  Otherwise, the expanded path will be returned.
       #
       #   Root.relative_filepath('dir', "dir/path/to/file.txt")  # => "path/to/file.txt"
       #
@@ -64,7 +66,7 @@ module Tap
   
         unless expanded[0...dir.length] == dir
           raise "\n#{expanded}\nis not relative to:\n#{dir}" if strict
-          return path
+          return expanded
         end
       
         # use dir.length + 1 to remove a leading '/'.   If dir.length + 1 >= expanded.length 
@@ -80,8 +82,8 @@ module Tap
         end.flatten.uniq
       end
     
-      # Lists all unique versions of path matching the glob version patterns.  If no patterns 
-      # are specified, then all versions of path will be returned.
+      # Lists all unique versions of path matching the glob version patterns.  
+      # If no patterns are specified, then all versions of path will be returned.
       def vglob(path, *vpatterns)
         vpatterns << "*" if vpatterns.empty?
         vpatterns.collect do |vpattern| 
@@ -92,30 +94,6 @@ module Tap
           results
         end.flatten.uniq
       end
-       
-
-    
-      #def package(target, *filepaths)
-       # options = filepaths.pop if filepaths.last.kind_of?(Hash)
-      #end
-      
-      # glob for dirs, remove if empty.  removes dir if empty on complete
-      # OR
-      # remove files older than a certain date
-      # remove all files
-      # 
-      #def cleanup(dir)
-      #end
-      
-      # iotask?
-      def parse_by_line(path, options={}, &block)
-        str = read(path, options.merge(:as => :txt))
-        lines = str.split(/\r?\n/)
-        lines.each do |line|
-          # don't yield empty lines because they split to [] (ie [nil, nil] for the block inputs)
-          yield(line.split(/#/, 2)) unless line.empty?
-        end
-      end
     end
   
     include Support::Versions
@@ -123,7 +101,7 @@ module Tap
     
     # Creates a new Root with the given root, directories, and absolute
     # paths.  By default root is the current working directory and no
-    # directories or absolute paths are specified.
+    # directories or absolute paths are specified.  
     def initialize(root=Dir.pwd, directories={}, absolute_paths={})
       assign_paths(root, directories, absolute_paths)
     end
@@ -133,44 +111,46 @@ module Tap
       assign_paths(path, directories, absolute_paths)
     end
   
-    # Sets the directories to those provided.  'root' and :root are reserved directory 
-    # keys and cannot be set using this method (use root= instead).
+    # Sets the directories to those provided.  'root' and :root are reserved  
+    # directory keys and cannot be set using this method (use root= instead).
     def directories=(dirs)
       assign_paths(root, dirs, absolute_paths)
     end
     
-    # Sets the absolute paths to those provided. 'root' and :root are reserved directory 
-    # keys and cannot be set using this method (use root= instead).
+    # Sets the absolute paths to those provided. 'root' and :root are reserved  
+    # directory keys and cannot be set using this method (use root= instead).
     def absolute_paths=(paths)
       assign_paths(root, directories, paths)
     end
     
-    # Returns the absolute paths registered with the Root.
+    # Returns the absolute paths registered with self.
     def absolute_paths
       abs_paths = {}
-      paths.each do |dir, path| 
-        abs_paths[dir] = path unless directories.include?(dir) || dir.to_s == 'root'
+      paths.each do |da, path| 
+        abs_paths[da] = path unless directories.include?(da) || da.to_s == 'root'
       end
       abs_paths
     end
 
-    # Sets the path to the specified directory, relative to the root directory.  
+    # Sets a directory alias (da) for the path relative to the root directory.  
     # The root directory cannot be set with this method (use root= instead). 
-    # Absolute filepaths can be set by specifying the absolute parameter.
+    # Absolute filepaths can be set using the second syntax.  
     #
-    #  root[:dir] = 'path/to/dir'
-    #  root[:root]      # => 'root_dir'
-    #  root[:dir]       # => 'root_dir/path/to/dir'
+    #  r = Root.new '/root_dir'
+    #  r[:dir] = 'path/to/dir'
+    #  r[:dir]       # => '/root_dir/path/to/dir'
     #
-    #  root[:abs, true] = '/abs/path/to/dir'  
-    #  root[:abs]       # => '/abs/path/to/dir'
+    #  r[:abs, true] = '/abs/path/to/dir'  
+    #  r[:abs]       # => '/abs/path/to/dir'
     # 
-    # Note - the syntax for setting an absolute filepath requires an odd use []=.  
+    #--
+    # The syntax for setting an absolute filepath requires an odd use []=.  
     # In fact the method recieves the arguments (:dir, true, '/abs/path/to/dir') 
     # rather than (:dir, '/abs/path/to/dir', true), meaning that internally path 
     # and absolute are switched when setting an absolute filepath.
-    def []=(dir, path, absolute=false)
-      raise ArgumentError, "The directory key '#{dir}' is reserved." if dir.to_s == 'root'
+    #++
+    def []=(da, path, absolute=false)
+      raise ArgumentError, "The directory key '#{da}' is reserved." if da.to_s == 'root'
   
       # switch the paths if absolute was provided
       unless absolute == false
@@ -181,94 +161,76 @@ module Tap
        
       case
       when path.nil? 
-        @directories.delete(dir)
-        @paths.delete(dir)
+        @directories.delete(da)
+        @paths.delete(da)
       when absolute
-        @directories.delete(dir)
-        @paths[dir] = path
+        @directories.delete(da)
+        @paths[da] = File.expand_path(path)
       else
-        @directories[dir] = path
-        @paths[dir] = File.join(root, path)
+        @directories[da] = path
+        @paths[da] = File.expand_path(File.join(root, path))
       end  
     end
   
-    # Returns the path to the specified directory.  If the path has not been set, 
-    # then the path is inferred to be 'root/dir'. 
-    def [](dir)
-      self.paths[dir] || File.join(root, dir.to_s)
+    # Returns the expanded path for the specified alias.  If the alias 
+    # has not been set, then the path is inferred to be 'root/da'.
+    #
+    #  r = Root.new '/root_dir'
+    #  r[:dir] = 'path/to/dir'
+    #  r[:dir]       # => '/root_dir/path/to/dir'
+    #
+    #  r[:unset] = nil
+    #  r[:unset]     # => '/root_dir/unset'
+    #
+    def [](da)
+      self.paths[da] || File.expand_path(File.join(root, da.to_s))
     end
     
-    # Constructs filepaths relative to the path of the specfied directory.
-    def filepath(dir, *filename)
-      File.join(self[dir], *filename)
+    # Constructs expanded filepaths relative to the path of the specified alias. 
+    def filepath(da, *filename)
+      File.expand_path(File.join(self[da], *filename))
     end
   
-    # Retrieves filepath relative to the path of the specified directory.  
-    def relative_filepath(dir, filepath, strict=true)
-      Root.relative_filepath(self[dir], filepath, strict)
+    # Retrieves the filepath relative to the path of the specified alias.  
+    def relative_filepath(da, filepath, strict=true)
+      Root.relative_filepath(self[da], filepath, strict)
     end
   
-    # Generates a target filepath translated from the input directory to the output directory.  
+    # Generates a target filepath translated from the aliased input dir to 
+    # the aliased output dir. Raises an error if the filepath is not relative 
+    # to the aliased input dir.
     # 
-    #   translate("/input/dir/path/to/input.txt") # => "/output/dir/path/to/input.txt"
-    def translate(filepath, input_dir, output_dir)
-      filepath(output_dir, relative_filepath(input_dir, filepath))
+    #  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_da, output_da)
+      filepath(output_da, relative_filepath(input_da, filepath))
     end
   
-    # Lists all files in the specified dir matching the input patterns.  Patterns should be valid inputs
-    # for +Dir.glob+.  If no patterns are specified, lists all files/folders matching '**/*'.
-    def glob(dir, *patterns)
+    # Lists all files in the aliased dir matching the input patterns.  Patterns 
+    # should be valid inputs for +Dir.glob+.  If no patterns are specified, lists 
+    # all files/folders matching '**/*'.
+    def glob(da, *patterns)
       patterns << "**/*" if patterns.empty?
-      patterns.collect! {|pattern| filepath(dir, pattern)}
+      patterns.collect! {|pattern| filepath(da, pattern)}
       Root.glob(*patterns)
     end
   
-    # Lists all versions of filename in the specified dir matching the version patterns.
+    # Lists all versions of filename in the aliased dir matching the version patterns.
     # If no patterns are specified, then all versions of filename will be returned.
-    def vglob(dir, filename, *vpatterns)
-      Root.vglob(filepath(dir, filename), *vpatterns)
-    end
-  
-    # Opens the file specfied by dir and filename, then passes the open file to the input block
-    def open(dir, filename, mode_string="r", &block)
-      File.open(filepath(dir, filename), mode_string, &block)
-    end
-  
-    # Reads the specififed file
-    def read(dir, filename)
-      File.read( filepath(dir, filename) )
-    end
-  
-    # 
-    def parse_by_line(dir, filename, options={}, &block)
-      Root.parse_by_line( filepath(dir, filename), options, &block)
-    end
-  
-    # The timestamp of the most recently modified file under dir.  Returns nil
-    # if none of the listed files are relative to dir.
-    def mtime(dir, *filenames)
-      filenames.collect do |fname| 
-        fname = relative_filepath(dir, fname, false)
-        path = filepath(dir, fname)
-      
-        File.exists?(path) ? File.mtime(path) : nil
-      end.compact.max
-    end
-  
-    # Makes all the directories specified in paths.  Parent directories are created as needed.
-    def mkpaths
-      paths.values.each { |dir| FileUtils.mkdir_p(dir) }
+    def vglob(da, filename, *vpatterns)
+      Root.vglob(filepath(da, filename), *vpatterns)
     end
     
     private
   
+    # reassigns all paths with the input root, directories, and absolute_paths
     def assign_paths(root, directories, absolute_paths)
-      @root = root
+      @root = File.expand_path(root)
       @directories = {}
-      @paths = {'root' => root, :root => root}
+      @paths = {'root' => @root, :root => @root}
       
-      directories.each_pair {|dir, path| self[dir] = path }
-      absolute_paths.each_pair {|dir, path| self[dir, true] = path }
+      directories.each_pair {|da, path| self[da] = path }
+      absolute_paths.each_pair {|da, path| self[da, true] = path }
     end  
 
   end