tap 0.19.0 → 1.3.0

data/lib/tap.rb

@@ -1,6 +1,75 @@
-lib = File.expand_path(File.dirname(__FILE__))
-$:.unshift(lib) unless $:.include?(lib)
-
+require 'tap/declarations'
 require 'tap/version'
-require 'tap/app'
-require 'tap/task'
+
+module Tap
+  module_function
+  
+  def options
+    options = {
+      :tapfile   => ENV['TAPFILE'],
+      :gems      => ENV['TAP_GEMS'],
+      :path      => ENV['TAP_PATH'],
+      :tapenv    => ENV['TAPENV'],
+      :taprc     => ENV['TAPRC'],
+      :tap_cache => ENV['TAP_CACHE'],
+      :debug     => ENV['TAP_DEBUG']
+    }
+    options
+  end
+  
+  def setup(options=self.options)
+    env = Env.new
+    app = App.new({}, :env => env)
+    app.set('app', app)
+    app.set('env', env)
+    App.current = app
+    
+    def options.process(key, default=nil)
+      value = self[key] || default
+      if self[:debug] == 'true'
+        $stderr.puts(App::LOG_FORMAT % [' ', nil, key, value])
+      end
+      value && block_given? ? yield(value) : nil
+    end
+    
+    if options[:debug] == 'true'
+      options.process(:ruby, "#{RbConfig::CONFIG['RUBY_INSTALL_NAME']}-#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})")
+      options.process(:tap, VERSION)
+      app.debug = true
+      app.verbose = true
+      app.logger.level = Logger::DEBUG
+    end
+    
+    options.process(:gems) do |gems|
+      cache_dir = options[:tap_cache]
+      
+      if cache_dir.to_s.strip.empty?
+        require 'tmpdir'
+        cache_dir = Dir.tmpdir
+      end
+      
+      env.signal(:load).call Env::Cache.new(cache_dir, options[:debug]).select(gems)
+    end
+    
+    options.process(:path) do |path|
+      Env::Path.split(path).each {|dir| env.auto(:dir => dir) }
+    end
+    
+    options.process(:tapenv) do |tapenv_path|
+      env.signal(:load).call Env::Path.split(tapenv_path)
+    end
+    
+    options.process(:taprc) do |taprc_path|
+      app.signal(:load).call Env::Path.split(taprc_path)
+    end
+    
+    options.process(:tapfile) do |tapfile_path|
+      Env::Path.split(tapfile_path).each do |tapfile|
+        next unless File.file?(tapfile)
+        Declarations::Context.new(app, File.basename(tapfile)).instance_eval(File.read(tapfile), tapfile, 1)
+      end
+    end
+    
+    app
+  end
+end

data/lib/tap/app.rb

@@ -1,46 +1,49 @@
 require 'logger'
-require 'tap/app/api'
-require 'tap/app/node'
+require 'tap/env'
 require 'tap/app/state'
 require 'tap/app/stack'
 require 'tap/app/queue'
-require 'tap/env'
-require 'tap/parser'
+autoload(:YAML, 'yaml')
 
 module Tap
-  
-  # :startdoc::app
-  #
   # App coordinates the setup and execution of workflows.
   class App
     class << self
-      # Sets the current app instance
-      attr_writer :instance
+      def set_context(context={})
+        current = Thread.current[CONTEXT]
+        Thread.current[CONTEXT] = context
+        current
+      end
+      
+      def with_context(context)
+        begin
+          current = set_context(context)
+          yield
+        ensure
+          set_context(current)
+        end
+      end
       
-      # Returns the current instance of App.  If no instance has been set,
-      # then instance initializes a new App with the default configuration.
-      # Instance is used to initialize tasks when no app is specified and
-      # exists for convenience only.
-      def instance(auto_initialize=true)
-        @instance ||= (auto_initialize ? new : nil)
+      def context
+        Thread.current[CONTEXT] ||= {}
       end
       
-      # Sets up and returns App.instance with an Env setup to the specified
-      # directory.  This method is used to initialize the app and env as seen
-      # by the tap executable.
-      def setup(dir=Dir.pwd)
-        env = Env.setup(dir)
-        @instance = new(:env => env)
+      def current=(app)
+        context[CURRENT] = app
       end
       
-      def build(spec={}, app=nil)
-        config = spec['config'] || {}
+      def current
+        context[CURRENT] ||= new
+      end
+      
+      def build(spec={}, app=current)
+        config  = spec['config'] || {}
         signals = spec['signals'] || []
         
         if spec['self']
           app.reconfigure(config)
         else
-          app = new(config)
+          app = new(config, :env => app.env)
         end
         
         signals.each do |args|
@@ -55,7 +58,12 @@ module Tap
     include Configurable
     include MonitorMixin
     include Signals
-    include Node
+    
+    # A variable to store the application context in Thread.current
+    CONTEXT = 'tap.context'
+    
+    # A variable to store an instance in the application context.
+    CURRENT = 'tap.current'
     
     # The reserved call keys
     CALL_KEYS = %w{obj sig args}
@@ -66,17 +74,30 @@ module Tap
     # Reserved call and init keys as a single array
     RESERVED_KEYS = CALL_KEYS + INIT_KEYS
     
-    # The default App logger (writes to $stderr at level INFO)
-    DEFAULT_LOGGER = Logger.new($stderr)
-    DEFAULT_LOGGER.level = Logger::INFO
-    DEFAULT_LOGGER.formatter = lambda do |severity, time, progname, msg|
-      "  %s[%s] %18s %s\n" % [severity[0,1], time.strftime('%H:%M:%S') , progname || '--' , msg]
+    # Splits a signal into an object string and a signal string.  If OBJECT
+    # doesn't match, then the string can be considered a signal, and the
+    # object is nil. After a match:
+    #
+    #   $1:: The object string
+    #        (ex: 'obj/sig' => 'obj')
+    #   $2:: The signal string
+    #        (ex: 'obj/sig' => 'sig')
+    #
+    OBJECT = /\A(.*)\/(.*)\z/
+    
+    # The default log format
+    LOG_FORMAT = "%s %8s %10s %s\n"
+    
+    # The default logger formatter -- uses LOG_FORMAT
+    LOG_FORMATTER = lambda do |severity, time, head, tail|
+      code = (severity == 'INFO' ? ' ' : severity[0,1])
+      LOG_FORMAT % [code, time.strftime('%H:%M:%S'), head, tail]
     end
     
     # The state of the application (see App::State)
     attr_reader :state
     
-    # The application call stack for executing nodes
+    # The application call stack for executing tasks
     attr_reader :stack
     
     # The application queue
@@ -88,60 +109,96 @@ module Tap
     # The application logger
     attr_accessor :logger
     
-    config :debug, false, :short => :d, &c.flag      # Flag debugging
-    config :force, false, :short => :f, &c.flag      # Force execution at checkpoints
-    config :quiet, false, :short => :q, &c.flag      # Suppress logging
-    config :verbose, false, :short => :v, &c.flag    # Enables extra logging (overrides quiet)
-    config :auto_enque, true, &c.switch              # Auto-enque parsed args
-    config :bang, true, &c.switch                    # Use parse! when possible
+    # The application environment
+    attr_accessor :env
     
-    nest :env, Env,                                  # The application environment
-      :type => :hidden,
-      :writer => false, 
-      :init => false
+    config :debug, false, :short => :d, &c.flag     # Flag debugging
+    config :force, false, :short => :f, &c.flag     # Force execution at checkpoints
+    config :quiet, false, :short => :q, &c.flag     # Suppress logging
+    config :verbose, false, :short => :v, &c.flag   # Enables extra logging (overrides quiet)
+    
+    define_signal :exe do |input|                   # executes an object
+      spec = convert_to_hash(input, ['var'], 'input')
+      obj.exe obj.obj(spec['var']), spec['input']
+    end
+    
+    define_signal :enq do |input|                   # enques an object
+      spec = convert_to_hash(input, ['var'], 'input')
+      obj.enq obj.obj(spec['var']), spec['input']
+    end
     
-    signal_hash :set,                                # set or unset objects
+    define_signal :pq do |input|                    # priority-enques an object
+      spec = convert_to_hash(input, ['var'], 'input')
+      obj.pq obj.obj(spec['var']), spec['input']
+    end
+    
+    signal_hash :set,                               # set or unset objects
       :signature => ['var', 'class'],
       :remainder => 'spec',
       :bind => :build
-      
-    signal :get, :signature => ['var']               # get objects
     
-    signal_class :list do                            # list available objects
-      def call(args) # :nodoc:
-        lines = obj.objects.collect {|(key, obj)|  "#{key}: #{obj.class}" }
-        lines.empty? ? "No objects yet..." : lines.sort.join("\n")
-      end
+    signal :get,                                    # get objects
+      :signature => ['var']
+    
+    signal_hash :bld,                               # build an object
+      :signature => ['class'],
+      :remainder => 'spec',
+      :bind => :build
+    
+    define_signal :use do |input|                   # enables middleware
+      spec = convert_to_hash(input, ['class'], 'spec')
+      obj.stack = obj.build(spec, &block)
     end
     
-    signal :enque                                   # enques an object
+    define_signal :configure, Configure             # configures the app
     
-    signal_class :parse do                          # parse a workflow
-      def call(args) # :nodoc:
-        argv = convert_to_array(args, ['args'])
-        obj.send(obj.bang ? :parse! : :parse, argv, &block)
-      end
+    signal :reset                                   # reset the app
+    signal :run                                     # run the app
+    signal :stop                                    # stop the app
+    signal :terminate                               # terminate the app
+    signal :info                                    # prints app status
+    
+    define_signal :list do |input|                  # list available objects
+      lines = obj.objects.collect {|(key, obj)|  "#{key}: #{obj.class}" }
+      lines.empty? ? "No objects yet..." : lines.sort.join("\n")
     end
     
-    signal_class :use do                             # enables middleware
-      def call(args) # :nodoc:
-        spec = convert_to_hash(args, ['class'], 'spec')
-        obj.stack = obj.build(spec, &block)
+    define_signal :serialize do |input|             # serialize the app as signals
+      if input.kind_of?(Array)
+        psr = ConfigParser.new
+        psr.on('--[no-]bare') {|value| psr['bare'] = value }
+        path, *ignored = psr.parse!(input)
+        psr['path'] = path
+        input = psr.config
       end
+      
+      bare = input.has_key?('bare') ? input['bare'] : true
+      signals = obj.serialize(bare)
+      
+      if path = input['path']
+        File.open(path, "w") {|io| YAML.dump(signals, io) }
+      else
+        YAML.dump(signals, $stdout)
+      end
+      
+      obj
     end
     
-    signal :run                                      # run the app
-    signal :stop                                     # stop the app
-    signal :terminate                                # terminate the app
-    signal :info                                     # prints app status
-    
-    signal_class :exit do                            # exit immediately
-      def process(args) # :nodoc:
-        exit(1)
+    define_signal :import do |input|                # import serialized signals
+      paths = convert_to_array(input, ['paths'])
+      paths.each do |path|
+        YAML.load_file(path).each do |signal|
+          obj.call(signal)
+        end
       end
+      
+      obj
     end
     
-    signal :help, :class => Help, :bind => nil       # signals help
+    define_signal :load, Load                       # load a tapfile
+    define_signal :help, Help                       # signals help
+    
+    cache_signals
     
     # Creates a new App with the given configuration.  Options can be used to
     # specify objects that are normally initialized for every new app:
@@ -150,36 +207,27 @@ module Tap
     #   :queue      the application queue; an App::Queue
     #   :objects    application objects; a hash of (var, object) pairs
     #   :logger     the application logger
+    #   :env        the application environment
     #
     # A block may also be provided; it will be set as a default join.
-    def initialize(config={}, options={}, &block)
+    def initialize(config={}, options={})
       super() # monitor
       
       @state = State::READY
       @stack = options[:stack] || Stack.new(self)
       @queue = options[:queue] || Queue.new
       @objects = options[:objects] || {}
-      @logger = options[:logger] || DEFAULT_LOGGER
-      @joins = []
-      on_complete(&block)
+      @logger = options[:logger] || begin
+        logger = Logger.new($stderr)
+        logger.level = Logger::INFO
+        logger.formatter = LOG_FORMATTER
+        logger
+      end
+      @env = options[:env] || Env.new
       
-      self.env = config.delete(:env) || config.delete('env')
       initialize_config(config)
     end
     
-    # Sets the application environment and validates that env provides an AGET
-    # ([]) and invert method.  AGET is used to lookup constants during init;
-    # it receives the 'class' parameter and should return a corresponding
-    # class.  Invert should return an object that reverses the AGET lookup.
-    # Tap::Env and a regular Hash both satisfy this api.
-    #
-    # Env can be set to nil and is set to nil by default, but initialization
-    # is constrained without it.
-    def env=(env)
-      Validation.validate_api(env, [:[], :invert]) unless env.nil?
-      @env = env
-    end
-    
     # Sets the application stack.
     def stack=(stack)
       synchronize do
@@ -187,11 +235,6 @@ module Tap
       end
     end
     
-    # True if the debug config or the global variable $DEBUG is true.
-    def debug?
-      debug || $DEBUG
-    end
-    
     # Logs the action and message at the input level (default INFO).  The
     # message may be generated by a block; in that case leave the message
     # unspecified as nil.
@@ -214,37 +257,23 @@ module Tap
     #   log(:action, "but a message with #{a}, #{b}, #{c}, and #{d}")
     #   log(:action) { "may be #{best} in a block because you can #{turn} #{it} #{off}" }
     #
-    def log(action, msg=nil, level=Logger::INFO)
+    def log(action='', msg=nil, level=Logger::INFO)
       if !quiet || verbose
-        msg ||= yield
-        logger.add(level, msg, action.to_s)
+        msg = yield if msg.nil? && block_given?
+        logger.add(level, msg.to_s, action.to_s)
       end
     end
     
-    # Returns a new node that executes block on call.
-    def node(&block) # :yields: *inputs
-      Node.intern(&block)
+    # Enques the task with the input.  Returns the task.
+    def enq(task, input=[])
+      queue.enq(task, input)
+      task
     end
     
-    # Enques the node with the inputs.  Returns the node.
-    def enq(node, *inputs)
-      queue.enq(node, inputs)
-      node
-    end
-    
-    # Generates a node from the block and enques. Returns the new node.
-    def bq(*inputs, &block) # :yields: *inputs
-      node = self.node(&block)
-      queue.enq(node, inputs)
-      node
-    end
-    
-    # Adds the specified middleware to the stack.  The argv will be used as
-    # extra arguments to initialize the middleware.
-    def use(middleware, *argv)
-      synchronize do
-        @stack = middleware.new(@stack, *argv)
-      end
+    # Priority-enques (unshifts) the task with the input.  Returns the task.
+    def pq(task, input=[])
+      queue.unshift(task, input)
+      task
     end
     
     # Sets the object to the specified variable and returns obj.  Provide nil
@@ -321,13 +350,20 @@ module Tap
     #   signal.call(args)            # call the signal with args
     #
     # Call returns the result of the signal call.
-    #
     def call(args, &block)
-      obj = args['obj']
-      sig = args['sig']
+      log(:call, nil, Logger::DEBUG) { args.inspect } if debug
+      
+      obj  = args['obj']
+      sig  = args['sig']
       args = args['args'] || args
       
-      route(obj, sig, &block).call(args)
+      # nil obj routes back to app, so optimize by evaluating signal directly
+      (obj.nil? ? signal(sig, &block) : route(obj, sig, &block)).call(args)
+    end
+    
+    def signal(sig, &block)
+      sig = sig.to_s
+      sig =~ OBJECT ? route($1, $2, &block) : super(sig, &block)
     end
     
     def route(obj, sig, &block)
@@ -341,41 +377,22 @@ module Tap
       
       object.signal(sig, &block)
     end
-
-    def resolve(const_str)
-      constant = env ? env[const_str] : Env::Constant.constantize(const_str)
-      constant or raise "unresolvable constant: #{const_str.inspect}"
+    
+    # Resolves the class in env and initializes a new instance with the args
+    # and block.  Note that the app is not appended to args by default.
+    def init(clas, *args, &block)
+      env.constant(clas).new(*args, &block)
     end
     
-    def build(spec)
-      var = spec['var']
+    def build(spec, &block)
+      var  = spec['var']
       clas = spec['class']
       spec = spec['spec'] || spec
-      obj = nil
-      
-      if clas.nil?
-        unless spec.empty?
-          raise "no class specified"
-        end
-      else
-        clas = resolve(clas)
-        
-        case spec
-        when Array
-          parse = bang ? :parse! : :parse
-          obj, args = clas.send(parse, spec, self)
       
-          if block_given?
-            yield(obj, args)
-          else
-            warn_ignored_args(args)
-          end
-        
-        when Hash
-          obj = clas.build(spec, self)
-        else
-          raise "invalid spec: #{spec.inspect}"
-        end
+      obj = nil
+      unless clas.nil?
+        method_name = spec.kind_of?(Array) ? :parse : :build
+        obj = env.constant(clas).send(method_name, spec, self, &block)
       end
       
       unless var.nil?
@@ -389,76 +406,12 @@ module Tap
       obj
     end
     
-    def parse(argv, &block) # :yields: spec
-      parse!(argv.dup, &block)
-    end
-    
-    def parse!(argv, &block) # :yields: spec
-      parser = Parser.new
-      argv = parser.parse!(argv)
-      
-      # The queue API does not provide a delete method, so picking out the
-      # deque jobs requires the whole queue be cleared, then re-enqued.
-      # Safety (and speed) is improved with synchronization.
-      queue.synchronize do
-        deque = []
-        blocks = {}
-        
-        if auto_enque
-          blocks[:node] = lambda do |obj, args|
-            queue.enq(obj, args)
-            args = nil
-          end
-          
-          blocks[:join] = lambda do |obj, args|
-            unless obj.respond_to?(:outputs)
-              # warning
-            end
-            deque.concat obj.outputs
-          end
-        end
-        
-        parser.specs.each do |spec|
-          if block_given?
-            next unless yield(spec)
-          end
-          
-          type, obj, sig, *args = spec
-          
-          sig_block = case sig
-          when 'set'
-            blocks[type]
-          when 'parse'
-            block
-          else
-            nil
-          end
-          
-          call('obj' => obj, 'sig' => sig, 'args' => args, &sig_block)  
-        end
-        
-        deque.uniq!
-        queue.clear.each do |(obj, args)|
-          if deque.delete(obj)
-            warn_ignored_args(args)
-          else
-            queue.enq(obj, args)
-          end
-        end
-      end
-
-      argv
-    end
-    
-    # Enques the application object specified by var with args.  Raises
-    # an error if no such application object exists.
-    def enque(var, *args)
-      unless node = get(var)
-        raise "unknown object: #{var.inspect}"
+    # Adds the specified middleware to the stack.  The argv will be used as
+    # extra arguments to initialize the middleware.
+    def use(clas, *argv)
+      synchronize do
+        @stack = init(clas, @stack, *argv)
       end
-      
-      queue.enq(node, args)
-      node
     end
     
     # Returns an array of middlware in use by self.
@@ -478,7 +431,7 @@ module Tap
           visited << current
           
           if circular_stack
-            visited.collect! {|middleware| middleware.class.to_s }.join(', ')
+            visited.collect! {|m| m.class.to_s }.join(', ')
             raise "circular stack detected:\n[#{visited}]"
           end
         end
@@ -503,53 +456,41 @@ module Tap
         objects.clear
         queue.clear
       end
+      self
     end
     
-    # Execute is a wrapper for dispatch allowing inputs to be listed out
-    # rather than provided as an array.
-    def execute(node, *inputs)
-      dispatch(node, inputs)
-    end
-    
-    # Dispatch does the following in order:
+    # Executes tasks by doing the following.
     #
-    # - call stack with the node and inputs
-    # - call the node joins (node.joins)
+    # - call stack with the task and input
+    # - call the task joins (task.joins)
     #
-    # The joins for self will be called if the node joins are an empty array.
-    # No joins will be called if the node joins are nil, or if the node does
-    # not provide a joins method.
-    #
-    # Dispatch returns the stack result.
-    def dispatch(node, inputs=[])
-      result = stack.call(node, inputs)
+    # Returns the stack result.
+    def exe(task, input=[])
+      log("#{var(task)} <<", "#{input.inspect} (#{task.class})", Logger::DEBUG) if debug
+      output = stack.call(task, input)
+      log("#{var(task)} >>", "#{output.inspect} (#{task.class})", Logger::DEBUG) if debug
       
-      if node.respond_to?(:joins)
-        if joins = node.joins
-
-          if joins.empty?
-            joins = self.joins
-          end
-        
+      if task.respond_to?(:joins)
+        if joins = task.joins
           joins.each do |join|
-            join.call(result)
+            join.call(output)
           end
         end
       end
       
-      result
+      output
     end
     
-    # Sequentially dispatches each enqued (node, inputs) pair to the
-    # application stack.  A run continues until the queue is empty.  
+    # Sequentially executes each enqued job (a [task, input] pair).  A run
+    # continues until the queue is empty.
     #
-    # Run checks the state of self before dispatching a node.  If the state
+    # Run checks the state of self before executing a task.  If the state
     # changes from RUN, the following behaviors result:
-    #   
-    #   STOP        No more nodes will be dispatched; the current node
+    #       
+    #   STOP        No more tasks will be executed; the current task
     #               will continute to completion.
-    #   TERMINATE   No more nodes will be dispatched and the currently
-    #               running node will be discontinued as described in
+    #   TERMINATE   No more tasks will be executed and the currently
+    #               running task will be discontinued as described in
     #               terminate.
     #
     # Calls to run when the state is not READY do nothing and return
@@ -564,12 +505,12 @@ module Tap
       
       begin
         while state == State::RUN
-          break unless entry = queue.deq
-          dispatch(*entry)
+          break unless job = queue.deq
+          exe(*job)
         end
       rescue(TerminateError)
         # gracefully fail for termination errors
-        queue.unshift(*entry)
+        queue.unshift(*job)
       ensure
         synchronize { @state = State::READY }
       end
@@ -577,8 +518,8 @@ module Tap
       self
     end
     
-    # Signals a running app to stop dispatching nodes to the application stack
-    # by setting state to STOP.  The node currently in the stack will continue
+    # Signals a running app to stop executing tasks to the application stack
+    # by setting state to STOP.  The task currently in the stack will continue
     # to completion.
     #
     # Does nothing unless state is RUN.
@@ -593,7 +534,7 @@ module Tap
     # them quietly.
     #
     # Nodes can set breakpoints that call check_terminate to invoke
-    # node-specific termination.  If a node never calls check_terminate, then
+    # task-specific termination.  If a task never calls check_terminate, then
     # it will continue to completion.
     #
     # Does nothing if state is READY.
@@ -622,42 +563,10 @@ module Tap
       "state: #{state} (#{State.state_str(state)}) queue: #{queue.size}"
     end
     
-    # Dumps self to the target as YAML. (note dump is still experimental)
-    #
-    # ==== Notes
-    #
-    # Platforms that use {Syck}[http://whytheluckystiff.net/syck/] (ex MRI)
-    # require a fix because Syck misformats certain dumps, such that they
-    # cannot be reloaded (even by Syck).  Specifically:
-    #
-    #   &id001 !ruby/object:Tap::Task ?
-    #
-    # should be:
-    #
-    #   ? &id001 !ruby/object:Tap::Task
-    #
-    # Dump fixes this error and, in addition, removes Thread and Proc dumps
-    # because they can't be allocated on load.
-    def dump(target=$stdout, options={})
-      synchronize do
-        options = {
-          :date_format => '%Y-%m-%d %H:%M:%S',
-          :date => true,
-          :info => true
-        }.merge(options)
-        
-        # print basic headers
-        target.puts "# date: #{Time.now.strftime(options[:date_format])}" if options[:date]
-        target.puts "# info: #{info}" if options[:info]
-        
-        # dump yaml, fixing as necessary
-        yaml = YAML.dump(self)
-        yaml.gsub!(/\&(.*!ruby\/object:.*?)\s*\?/) {"? &#{$1} " } if YAML.const_defined?(:Syck)
-        yaml.gsub!(/!ruby\/object:(Thread|Proc) \{\}/, '')
-        target << yaml
-      end
-      
-      target
+    # Sets self as instance in the current context, for the duration of the
+    # block (see App.with_context).
+    def scope
+      App.with_context(CURRENT => self) { yield }
     end
     
     # Converts the self to a schema that can be used to build a new app with
@@ -677,8 +586,8 @@ module Tap
       order = []
       
       # collect enque signals to setup queue
-      signals = queue.to_a.collect do |(node, args)|
-        {'sig' => 'enque', 'args' => [var(node)] + args}
+      signals = queue.to_a.collect do |(task, input)|
+        {'sig' => 'enq', 'args' => {'var' => var(task), 'input' => input}}
       end
       
       # collect and trace application objects
@@ -708,7 +617,6 @@ module Tap
         (variables[obj] ||= []) << var
       end
       
-      invert_env = env ? env.invert : nil
       specs.keys.each do |obj|
         spec = {'sig' => 'set'}
         
@@ -722,9 +630,7 @@ module Tap
         end
 
         # assign the class
-        klass = obj.class
-        klass = invert_env[klass] if invert_env
-        spec['class'] = klass.to_s
+        spec['class'] = obj.class.to_s
 
         # merge obj_spec if possible
         obj_spec = specs[obj]
@@ -770,17 +676,10 @@ module Tap
     def inspect
       "#<#{self.class}:#{object_id} #{info}>"
     end
-
+    
     private
-
-    # warns of ignored args
-    def warn_ignored_args(args) # :nodoc:
-      if args && debug? && !args.empty?
-        warn "ignoring args: #{args.inspect}"
-      end
-    end
     
-    # Traces each object backwards and forwards for node, joins, etc. and adds
+    # Traces each object backwards and forwards for tasks, joins, etc. and adds
     # each to specs as needed.  The trace determines and returns the order in
     # which these specs must be initialized to make sense.  Circular traces
     # are detected.
@@ -812,6 +711,10 @@ module Tap
       # obj must exist before brefs (back-references)
       if obj.respond_to?(:associations)
         refs, brefs = obj.associations
+        
+        unless array_or_nil?(refs) && array_or_nil?(brefs)
+          raise "invalid associations on object (refs, brefs must be an array or nil): #{obj.inspect}"
+        end
       
         refs.each {|ref| trace(ref, specs, order) } if refs
         order << obj
@@ -823,12 +726,16 @@ module Tap
       order
     end
     
+    def array_or_nil?(obj) # :nodoc:
+      obj.nil? || obj.kind_of?(Array)
+    end
+    
     def self_to_spec # :nodoc:
       config = self.config.to_hash {|hash, key, value| hash[key.to_s] = value }
       {'config' => config, 'self' => true}
     end
     
-    # TerminateErrors are raised to kill executing nodes when terminate is 
+    # TerminateErrors are raised to kill executing tasks when terminate is 
     # called on an running App.  They are handled by the run rescue code.
     class TerminateError < RuntimeError
     end