tap 0.12.3 → 0.12.4

data/History

@@ -1,3 +1,14 @@
+== 0.12.4 / 2009-03-23
+
+* fixed bug in App#inspect
+* documentation updates
+* changed the default load/dump configs to load and
+  dump data without serialization
+* made stdin the default input to load
+* updated run syntax to allow arguments to be passed
+  to saved workflows
+* updates to RootGenerator
+
 == 0.12.3 / 2009-03-05
 
 * Updates to allow Tap to use the latest Configurable.

data/README

@@ -52,7 +52,6 @@ Tap pulls documentation out of task classes to generate manifests:
     sample:
       goodnight   # your basic goodnight moon task
     tap:
-      core_dump   # dumps the application
       dump        # the default dump task
       load        # the default load task
       

data/bin/tap

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
-# usage: tap <command> {options} [args]
+# usage: tap <command> {options} [args] [-d-]
+#
+# Launches a tap command. To enable debugging, append the -d- superflag.
 #
 # examples:
 #   tap generate root .                  # generates a root dir
@@ -14,11 +16,7 @@ require "#{File.dirname(__FILE__)}/../lib/tap.rb"
 
 # setup the environment
 begin
-  
-  # handle super options
-  $DEBUG = true if ARGV.delete('-d-')
-  env = Tap::Exe.instantiate
-  
+  env = Tap::Exe.setup(ARGV)
 rescue(Tap::Env::ConfigError)
   # catch errors and exit gracefully
   # (errors usu from gem loading errors)

data/cmd/run.rb

@@ -1,8 +1,13 @@
-# usage: tap run FILEPATHS... [options] -- [SCHEMA]
+# usage: tap run [args] [options] -- [SCHEMA]
 #
 # examples:
 #   tap run --help                     Prints this help
+#   tap run -w workflow.yml            Build and run a workflow
+#   tap run -w workflow.yml a b c      Same with [a, b, c] ARGV
+#
+# schema:
 #   tap run -- task --help             Prints help for task
+#   tap run -- load hello --: dump     Say hello
 #
 
 env = Tap::Env.instance
@@ -12,10 +17,10 @@ app = Tap::App.instance
 # divide argv
 #
 
-run_argv = []
+argv = []
 break_regexp = Tap::Support::Parser::BREAK
 while !ARGV.empty? && ARGV[0] !~ break_regexp
-  run_argv << ARGV.shift
+  argv << ARGV.shift
 end
 
 #
@@ -35,7 +40,7 @@ ConfigParser.new do |opts|
  
   opts.separator ""
   opts.separator "options:"
- 
+  
   opts.on("-h", "--help", "Show this message") do
     Tap::App.lazydoc.resolve
     puts Lazydoc.usage(__FILE__)
@@ -48,29 +53,32 @@ ConfigParser.new do |opts|
     exit
   end
   
-end.parse!(run_argv, app.config)
+  opts.on("-w", "--workflow FILE", "Build the workflow file") do |path|
+    unless File.exists?(path)
+      puts "No such file or directory - #{path}"
+      puts "(did you mean 'tap run -- #{path}'?)"
+      exit
+    end
+
+    schema = Tap::Support::Schema.load_file(path)
+    env.build(schema, app)
+  end
+  
+end.parse!(argv, app.config)
 
 #
 # build and run the argv
 #
 
-run_argv.each do |path|
-  unless File.exists?(path)
-    puts "No such file or directory - #{path}"
-    puts "(did you mean 'tap run -- #{path}'?)"
-    exit
-  end
-  
-  schema = Tap::Support::Schema.load_file(path)
-  env.build(schema, app)
-end
-
 schema = Tap::Support::Schema.parse(ARGV)
-ARGV.clear
 env.build(schema, app)
+ARGV.replace(argv)
 
 if app.queue.empty?
   puts "no task specified"
+  unless ARGV.empty?
+    puts "(did you mean 'tap run -- #{ARGV.join(' ')}'?)"
+  end
   exit
 end
 

data/lib/tap/app.rb

@@ -197,8 +197,8 @@ module Tap
       self.logger = logger
     end
     
-    # The default App logger writes to $stdout at level INFO.
-    DEFAULT_LOGGER = Logger.new($stdout)
+    # 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]
@@ -356,11 +356,6 @@ module Tap
       self
     end
     
-    # Returns a string like: "#<Tap::App:#{object_id} root: #{root} >"
-    def inspect
-      "#<#{self.class.to_s}:#{object_id} root: #{root} >"
-    end
-    
     # 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 

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 12
-  TINY = 3
+  TINY = 4
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/dump.rb

@@ -0,0 +1,142 @@
+module Tap
+
+  # :startdoc::manifest the default dump task
+  #
+  # A dump task to output results.  Unlike most tasks, dump does not enque
+  # arguments from the command line; instead command line arguments are only
+  # used to setup the dump.  Specifically dump accepts a filepath.
+  #
+  #   % tap run -- [task] --: dump FILEPATH
+  #
+  # Results that come to dump are appended to the file.  Dump only accepts
+  # one object at a time, so joins that produce an array need to iterate
+  # outputs to dump:
+  #
+  #   % tap run -- load hello -- load world "--2(0,1)i" dump 
+  #
+  # Note that dump uses $stdout by default so you can pipe or redirect dumps
+  # as normal.
+  #
+  #   % tap run -- load hello --: dump | cat
+  #   hello
+  #
+  #   % tap run -- load hello --: dump 1> results.txt
+  #   % cat results.txt
+  #   hello
+  #
+  # :startdoc::manifest-
+  #
+  # Dump serves as a baseclass for more complicated dump tasks.  A YAML dump
+  # task (see {tap-tasks}[http://tap.rubyforge.org/tap-tasks]) looks like this:
+  #
+  #   class Yaml < Tap::Dump
+  #     def dump(obj, io)
+  #       YAML.dump(obj, io)
+  #     end
+  #   end
+  #
+  # === Implementation Notes
+  #
+  # Dump passes on the command line arguments to setup rather than process.
+  # Moreover, process will always receive the audits passed to _execute, rather
+  # than the audit values. This allows a user to provide setup arguments (such
+  # as a dump path) on the command line, and provides dump the opportunity to
+  # inspect audit trails within process.
+  #
+  class Dump < Tap::Task
+    class << self
+      
+      # Same as an ordinary parse!, except the arguments normally reserved for
+      # executing the task are used to call setup.  The return will always be
+      # an instance and an empty array.
+      def parse!(argv=ARGV, app=Tap::App.instance)
+        instance, args = super
+        instance.setup(*args)
+        [instance, []]
+      end
+    end
+    
+    lazy_attr :args, :setup
+    lazy_register :setup, Lazydoc::Arguments
+    
+    config :date_format, '%Y-%m-%d %H:%M:%S'   # The date format
+    config :audit, false, &c.switch            # Include the audit trails
+    config :date, false, &c.switch             # Include a date
+    
+    # The dump target, by default $stdout.  Target may be a filepath,
+    # in which case dumps append the file.
+    attr_accessor :target
+    
+    def initialize(config={}, name=nil, app=App.instance)
+      super(config, name, app)
+      @target = $stdout
+    end
+    
+    # Setup self with the input target.  Setup receives arguments passed from
+    # the command line, via parse!
+    def setup(output=$stdout)
+      @target = output
+      self
+    end
+    
+    # Overrides the standard _execute to send process the audits and not
+    # the audit values.  This allows process to inspect audit trails.
+    def _execute(input)
+      resolve_dependencies
+      
+      previous = input.kind_of?(Support::Audit) ? input : Support::Audit.new(nil, input)
+      input = previous.value
+      
+      # this is the overridden part
+      audit = Support::Audit.new(self, input, app.audit ? previous : nil)
+      send(method_name, audit)
+      
+      if complete_block = on_complete_block || app.on_complete_block
+        complete_block.call(audit)
+      else 
+        app.aggregator.store(audit)
+      end
+      
+      audit
+    end
+    
+    # The default process prints dump headers as specified in the config,
+    # then append the audit value to io.
+    def process(_audit)
+      open_io(target) do |io|
+        if date
+          io.puts "# date: #{Time.now.strftime(date_format)}"
+        end
+
+        if audit
+          io.puts "# audit:"
+          io.puts "# #{_audit.dump.gsub("\n", "\n# ")}"
+        end
+        
+        dump(_audit.value, io)
+      end
+    end
+    
+    # Dumps the object to io, by default dump puts (not prints) obj.to_s.
+    def dump(obj, io)
+      io.puts obj.to_s
+    end
+    
+    protected
+    
+    # helper to open and yield the io specified by target.  open_io
+    # ensures file targets are closed when the block returns.
+    def open_io(io) # :nodoc:
+      case io
+      when IO, StringIO 
+        yield(io)
+      when String
+        dir = File.dirname(io)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        File.open(io, 'a') {|file| yield(file) }  
+      else
+        raise "cannot open io: #{target.inspect}"
+      end
+    end
+  end
+end

data/lib/tap/env.rb

@@ -103,7 +103,7 @@ module Tap
     attr_reader :envs
     
     # The Root directory structure for self.
-    nest(:root, Tap::Root, :initializer => false)
+    nest(:root, Tap::Root, :set_default => false)
     
     # Specify gems to load as nested Envs.  Gems may be specified 
     # by name and/or version, like 'gemname >= 1.2'; by default the 
@@ -213,10 +213,16 @@ module Tap
       @gems = []
       @env_paths = []
       
-      initialize_config case path_root_or_config
-      when String, Root then {:root => path_root_or_config}
-      else path_root_or_config
+      @root = case path_root_or_config
+      when Root then path_root_or_config
+      when String then Root.new(path_root_or_config)
+      else Root.new
       end
+      
+      unless path_root_or_config.kind_of?(Hash)
+        path_root_or_config = {}
+      end
+      initialize_config(path_root_or_config)
     end
     
     # Clears manifests so they may be regenerated.
@@ -476,14 +482,6 @@ module Tap
     # A hash of the manifests for self.
     attr_reader :manifests
     
-    def initialize_root(config)
-      case config
-      when Root then config
-      when String then Root.new(config)
-      else Root.new.reconfigure(config)
-      end
-    end
-    
     def minikey(env)
       env.root.root
     end

data/lib/tap/exe.rb

@@ -5,6 +5,15 @@ require 'tap/support/schema'
 module Tap
   class Exe < Env
     class << self
+      def setup(argv=ARGV)
+        if argv[-1] == '-d-'
+          argv.pop
+          $DEBUG = true 
+        end
+        
+        instantiate
+      end
+      
       def instantiate(path_or_root=Dir.pwd)
         exe = super
         
@@ -121,7 +130,7 @@ module Tap
       end
     end
     
-    def set_signals
+    def set_signals(app=Tap::App.instance)
       # info signal -- Note: some systems do 
       # not support the INFO signal 
       # (windows, fedora, at least)

data/lib/tap/file_task.rb

@@ -34,11 +34,11 @@ module Tap
     include Tap::Support::ShellUtils
     
     # The backup directory
-    config_attr :backup_dir, 'backup'            # the backup directory
+    config_attr :backup_dir, 'backup'            # The backup directory
     
     # A flag indicating whether or track changes
     # for rollback on execution error
-    config :rollback_on_error, true, &c.switch   # rollback changes on error
+    config :rollback_on_error, true, &c.switch   # Rollback changes on error
     
     def initialize(config={}, name=nil, app=App.instance)
       super

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

@@ -19,8 +19,9 @@ module Tap::Generator::Generators
   #
   class RootGenerator < Tap::Generator::Base
     
-    config :config_file, true, &c.switch   # Create a tap.yml file
+    config :config_file, false, &c.switch  # Create a full tap.yml file
     config :license, true, &c.switch       # Create an MIT-LICENSE
+    config :history, true, &c.switch       # Create History file
     config :rapfile, false, &c.switch      # Create a Rapfile
     
     # ::args ROOT, PROJECT_NAME=basename(ROOT)
@@ -38,7 +39,12 @@ module Tap::Generator::Generators
           m.directory r[target]
           next
         when source =~ /gemspec$/
-          m.template r[project_name + '.gemspec'], source, :project_name => project_name, :config_file => config_file, :license => license
+          m.template r[project_name + '.gemspec'], source, {
+            :project_name => project_name, 
+            :config_file => config_file, 
+            :license => license,
+            :history => history
+          }
           next
         when source =~ /Rapfile$/
           next unless rapfile
@@ -49,6 +55,7 @@ module Tap::Generator::Generators
         m.template r[target], source, :project_name => project_name, :license => license
       end
       
+      m.file(r['History']) if history
       m.file(r['tap.yml']) do |file|
         Configurable::Utils.dump(Tap::Env.configurations, file) do |key, delegate|
           default = delegate.default(false)
@@ -69,8 +76,8 @@ module Tap::Generator::Generators
           leader = key == 'root' || default == nil ? '# ' : ''
           config = YAML.dump({key => default})[5..-1].strip.gsub(/\n+/, "\n#{leader}")
           "#{lines.join("\n")}#{leader}#{config}\n\n"
-        end
-      end if config_file
+        end if config_file
+      end
     end
     
   end

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

@@ -14,13 +14,14 @@ Gem::Specification.new do |s|
   
   # list extra rdoc files here.
   s.extra_rdoc_files = %W{
+<%= history ? "    History\n" : '' %>
     README
 <%= license ? "    MIT-LICENSE\n" : '' %>
   }
   
   # list the files you want to include here. you can
-  # check this manifest using 'rake :print_manifest'
+  # check this manifest using 'rap print_manifest'
   s.files = %W{
-<%= config_file ? "    tap.yml\n" : '' %>
+    tap.yml
   }
 end

data/lib/tap/load.rb

@@ -0,0 +1,64 @@
+require 'stringio'
+
+module Tap
+  # :startdoc::manifest the default load task
+  #
+  # Loads data from the input IO; string data is simply passed through.  Load
+  # is typically used as a gateway to other tasks.
+  #
+  #   % tap run -- load string --: [task]
+  #
+  # Note that load takes $stdin by default, so you can pipe or redirect data
+  # into to a workflow like so:
+  #
+  #   % echo 'hello' | tap run -- load --: dump --audit
+  #   # audit:
+  #   # o-[tap/load] "hello\n"
+  #   # o-[tap/dump] ["hello\n"]
+  #   #
+  #   hello
+  #
+  #   % tap run -- load --: dump --audit < 'somefile.txt'
+  #   # audit:
+  #   # o-[tap/load] "contents of somefile\n"
+  #   # o-[tap/dump] ["contents of somefile\n"]
+  #   #
+  #   contents of somefile
+  #
+  # ::manifest-
+  #
+  # Load serves as a baseclass for more complicated load tasks.  A YAML load
+  # task (see {tap-tasks}[http://tap.rubyforge.org/tap-tasks]) looks like this:
+  #
+  #   class Yaml < Tap::Load
+  #     def load(io)
+  #       YAML.load(io)
+  #     end
+  #   end
+  #
+  class Load < Tap::Task
+    
+    # The default process simply reads the input data and returns it.
+    # See load.
+    def process(input=$stdin)
+      # read on an empty stdin ties up the command line;
+      # this facilitates the intended behavior
+      if input == $stdin && input.stat.size == 0
+        input = '' 
+      end
+      
+      case input
+      when StringIO, IO
+        load(input)
+      else
+        load(StringIO.new(input))
+      end
+    end
+    
+    # Loads data from the io; the return of load is the return of process.  By
+    # default load simply reads data from io.
+    def load(io)
+      io.read
+    end
+  end 
+end

data/lib/tap/support/constant.rb

@@ -72,9 +72,8 @@ module Tap
       # The path to load to initialize a missing constant
       attr_reader :require_path
       
-      # Initializes a new Constant with the specified constant
-      # name and require_path.  The name should be a valid
-      # constant name.
+      # Initializes a new Constant with the specified constant name and
+      # require_path.  The name should be a valid constant name.
       def initialize(name, require_path=nil)
         @name = name
         @require_path = require_path
@@ -100,7 +99,7 @@ module Tap
         @const_name ||= (name =~ /.*::(.*)$/ ? $1 : name)
       end
       
-      # Returns an array of the nesting constants of name.
+      # Returns the nesting constants of name.
       def nesting
         @nesting ||= (name =~ /(.*)::.*$/ ? $1 : '')
       end
@@ -123,9 +122,8 @@ module Tap
         another.require_path == self.require_path
       end
       
-      # Looks up and returns the constant indicated by name.
-      # If the constant cannot be found, the constantize
-      # requires require_path and tries again.  
+      # Looks up and returns the constant indicated by name. If the constant
+      # cannot be found, constantize requires require_path and tries again.  
       #
       # Raises a NameError if the constant cannot be found.
       def constantize

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap
 version: !ruby/object:Gem::Version 
-  version: 0.12.3
+  version: 0.12.4
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-05 00:00:00 -07:00
+date: 2009-03-23 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.4.0
+        version: 0.4.1
     version: 
 description: 
 email: simon.a.chiang@gmail.com
@@ -97,9 +97,8 @@ files:
 - lib/tap/support/templater.rb
 - lib/tap/support/versions.rb
 - lib/tap/task.rb
-- lib/tap/tasks/core_dump.rb
-- lib/tap/tasks/dump.rb
-- lib/tap/tasks/load.rb
+- lib/tap/dump.rb
+- lib/tap/load.rb
 - lib/tap/test.rb
 - lib/tap/test/assertions.rb
 - lib/tap/test/env_vars.rb

data/lib/tap/tasks/core_dump.rb

@@ -1,57 +0,0 @@
-module Tap
-  module Tasks
-    # :startdoc::manifest dumps the application
-    #
-    # A dump task to print the application data to a file or IO.  Currently the
-    # dump result is only useful for viewing results.  In the future the core
-    # dump will be reloadable so a terminated app may restart execution.
-    #
-    # A core dump may be used in a terminal round to capture all the unhandled
-    # results from previous rounds; if no filepath is specified, the results
-    # are printed to stdout.
-    #  
-    #   % tap run -- [tasks] --+ core_dump FILEPATH
-    #
-    class CoreDump < Tap::FileTask
-      
-      config :date, true, &c.switch              # include a date
-      config :date_format, '%Y-%m-%d %H:%M:%S'   # the date format
-      config :info, true, &c.switch              # dump the app state information
-      config :aggregator, true, &c.switch        # dump aggregator results
-      config :audit, true, &c.switch             # include the audit trails with results
-      
-      def process(target=$stdout)
-        case target
-        when IO then dump_to(target)
-        when String
-          log_basename(:dump, target)
-          prepare(target)
-          File.open(target, "wb") {|file| dump_to(file) }
-        else
-          raise "cannot dump to: #{target.inspect}"
-        end
-      end
-    
-      def dump_to(io)
-        io.puts "# date: #{Time.now.strftime(date_format)}" if date
-        io.puts "# info: #{app.info}" if info
-        
-        if aggregator
-          trails = []
-          results = {}
-          app.aggregator.to_hash.each_pair do |src, _results|
-            results["#{src} (#{src.object_id})"] = _results.collect {|_audit| _audit.value }
-            _results.each {|_audit| trails << _audit.dump }
-          end
-      
-          if audit
-            io.puts "# audit:"
-            trails.each {|trail| io.puts "# #{trail.gsub("\n", "\n# ")}"}
-          end
-                
-          YAML::dump(results, io)
-        end
-      end
-    end
-  end
-end

data/lib/tap/tasks/dump.rb

@@ -1,125 +0,0 @@
-module Tap
-  module Tasks
-    # :startdoc::manifest the default dump task
-    #
-    # A dump task to print results as YAML.  Unlike most tasks, dump arguments
-    # do not enque to the task; instead the arguments are used to setup a
-    # dump and the dump uses whatever results come to them in a workflow.
-    #
-    # Multiple dumps to the same file append rather than overwrite.  If no file
-    # is specified, the dump goes to $stdout.
-    #
-    #   % tap run -- [task] --: dump FILEPATH
-    #
-    # Results may be printed directly, without conversion to YAML by using the
-    # --no-yaml option.
-    #
-    # :startdoc::manifest-
-    #
-    # Dumps are organized so that arguments passed on the command line are
-    # directed at setup rather than process.  Moreover, process will always
-    # receive the audits passed to _execute, rather than the audit values.
-    # This allows a user to provide setup arguments (such as a dump path)
-    # on the command line, and provides dump the opportunity to inspect
-    # audit trails.
-    #
-    class Dump < Tap::FileTask
-      class << self
-        
-        # Same as an ordinary parse!, except the arguments normally reserved for
-        # executing the task are used to call setup.  The return will always be
-        # an instance and an empty array.
-        def parse!(argv=ARGV, app=Tap::App.instance)
-          instance, args = super
-          instance.setup(*args)
-          [instance, []]
-        end
-      end
-      
-      lazy_attr :args, :setup
-      lazy_register :setup, Lazydoc::Arguments
-      
-      config :date_format, '%Y-%m-%d %H:%M:%S'   # the date format
-      config :audit, true, &c.switch             # include the audit trails
-      config :date, true, &c.switch              # include a date
-      config :yaml, true, &c.switch              # dump as yaml (vs string)
-      
-      # The dump target, by default $stdout.  Target may be a filepath,
-      # in which case dumps append the file.
-      attr_accessor :target
-      
-      def initialize(config={}, name=nil, app=App.instance, target=$stdout)
-        super(config, name, app)
-        @target = target
-      end
-      
-      # Setup self with the input target.  Setup is typically called from
-      # parse! and receives arguments passed from the command line.
-      def setup(path=target)
-        @target = path
-      end
-      
-      # Overrides the standard _execute to send process the audits and not
-      # the audit values.  This allows process to inspect audit trails.
-      def _execute(*inputs)
-        resolve_dependencies
-        
-        previous = []
-        inputs.collect! do |input| 
-          if input.kind_of?(Support::Audit) 
-            previous << input
-            input.value
-          else
-            previous << Support::Audit.new(nil, input)
-            input
-          end
-        end
-        
-        # this is the overridden part
-        audit = Support::Audit.new(self, inputs, app.audit ? previous : nil)
-        send(method_name, audit)
-        
-        if complete_block = on_complete_block || app.on_complete_block
-          complete_block.call(audit)
-        else 
-          app.aggregator.store(audit)
-        end
-        
-        audit
-      end
-      
-      # Prints the _audit to the target.  The return value of process is
-      # not recorded in the audit trail.
-      def process(_audit)
-        open_io do |io|
-          if date
-            io.puts "# date: #{Time.now.strftime(date_format)}"
-          end
-          
-          if audit
-            io.puts "# audit:"
-            io.puts "# #{_audit.dump.gsub("\n", "\n# ")}"
-          end
-          
-          if yaml
-            YAML::dump(_audit.value, io)
-          else
-            io << _audit.value.to_s
-          end
-        end
-      end
-      
-      protected
-      
-      # helper to open and yield the io specified by target.  open_io
-      # ensures file targets are closed when the block returns.
-      def open_io # :nodoc:
-        case target
-        when IO, StringIO then yield(target)
-        when String then File.open(target, 'a') {|io| yield(io) }  
-        else raise "cannot open target: #{target.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/tap/tasks/load.rb

@@ -1,31 +0,0 @@
-module Tap
-  module Tasks
-    # :startdoc::manifest the default load task
-    #
-    # Loads YAML-formatted data and makes the result available for other tasks.
-    # Use the --no-yaml configuration to read the data without loading as YAML.
-    #
-    # Load is typically used as a gateway task to other tasks.
-    #
-    #   % tap run -- load FILEPATH --: [task]
-    #
-    class Load < Tap::Task
-      
-      config :yaml, true, &c.switch              # load as yaml (vs string)
-      
-      # Loads the input as YAML.  Input may be an IO, StringIO, or a filepath.
-      # The loaded object is returned directly.
-      def process(input)
-        str = case input
-        when StringIO, IO
-          input.read
-        else
-          log :load, input
-          File.read(input)
-        end
-        
-        yaml ? YAML.load(str) : str
-      end
-    end 
-  end
-end