tap-server 0.1.1 → 0.2.0

data/History

@@ -1,3 +1,7 @@
+== 0.2.0 / 2009-03-07
+
+* Reworked server routing to route by ::controller
+
 == 0.1.1 / 2009-02-23
 
 Update executable to use Tap-0.12.2.

data/README

@@ -45,5 +45,5 @@ Tap requires an updated version of RubyGems[http://docs.rubygems.org/]
 Copyright (c) 2009, Regents of the University of Colorado.
 Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
 Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
-Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]
+License:: {MIT-Style}[link:files/MIT-LICENSE.html]
 

data/lib/tap/controllers/app.rb

@@ -0,0 +1,98 @@
+require 'tap/controller'
+require 'rack/mime'
+require 'time'
+
+module Tap
+  module Controllers
+    
+    # ::controller
+    class App < Tap::Controller
+      set :default_layout, 'layout.erb'
+  
+      def call(env)
+        # serve public files before actions
+        server = env['tap.server'] ||= Tap::Server.new
+    
+        if path = server.public_path(env['PATH_INFO'])
+          content = File.read(path)
+          headers = {
+            "Last-Modified" => [File.mtime(path).httpdate],
+            "Content-Type" => [Rack::Mime.mime_type(File.extname(path), 'text/plain')], 
+            "Content-Length" => [content.size.to_s]
+          }
+      
+          [200, headers, [content]]
+        else
+          super
+        end
+      end
+  
+      def index
+        env_names = {}
+        server.env.minimap.each do |name, environment|
+          env_names[environment] = name
+        end 
+    
+        render('index.erb', :locals => {:env => server.env, :env_names => env_names}, :layout => true)
+      end
+  
+      def info
+        if request.post?
+          app.info
+        else
+          render('info.erb', :locals => {:update => true, :content => app.info}, :layout => true)
+        end
+      end
+  
+      #--
+      # Currently tail is hard-coded to tail the server log only.
+      def tail(id=nil)
+        begin
+          path = root.subpath(:log, 'server.log')
+          raise unless File.exists?(path)
+        rescue
+          raise Tap::ServerError.new("invalid path", 404)
+        end
+    
+        pos = request['pos'].to_i
+        if pos > File.size(path)
+          raise Tap::ServerError.new("tail position out of range (try update)", 500)
+        end
+
+        content = File.open(path) do |file|
+          file.pos = pos
+          file.read
+        end
+    
+        if request.post?
+          content
+        else
+          render('tail.erb', :locals => {
+            :id => id,
+            :path => File.basename(path),
+            :update => true,
+            :content => content
+          }, :layout => true)
+        end
+      end
+  
+      def run
+        Thread.new { app.run }
+        redirect("/app/tail")
+      end
+  
+      def stop
+        app.stop
+        redirect("/app/info")
+      end
+  
+      def terminate
+        app.terminate
+        redirect("/app/info")
+      end
+  
+      def help(key=nil)
+      end
+    end
+  end
+end

data/lib/tap/controllers/schema.rb

@@ -0,0 +1,261 @@
+require 'tap/controller'
+
+module Tap
+  module Controllers
+    
+    # ::controller
+    class Schema < Tap::Controller
+      set :default_layout, 'layout.erb'
+  
+      # Initializes a new schema and redirects to display.
+      def index
+        id = initialize_schema
+        redirect("/schema/display/#{id}")
+      end
+  
+      # Loads the schema indicated by id and renders 'schema.erb' with the default
+      # layout.
+      def display(id)
+        schema = load_schema(id)
+        render 'schema.erb', :locals => {
+          :id => id, 
+          :schema => schema
+        }, :layout => true
+      end
+  
+      # Updates the specified schema with the request parameters.  Update forwards
+      # the request to the action ('add' or 'remove') specified in the action
+      # parameter.
+      def update(id)
+        case request['action']
+        when 'add'    then add(id)
+        when 'remove' then remove(id)
+        when 'echo'   then echo
+        else raise Tap::ServerError, "unknown action: #{request['action']}"
+        end
+      end
+  
+      # Adds nodes or joins to the schema.  Parameters:
+      #
+      # nodes[]:: An array of nodes to add to the schema. Each entry is split using
+      #           Shellwords to yield an argv; the argv initializes the node.  The
+      #           index of each new node is added to targets[].
+      # sources[]:: An array of source node indicies used to create a join.
+      # targets[]:: An array of target node indicies used to create a join (note
+      #             the indicies of new nodes are added to targets).
+      #
+      # Add creates and pushes new nodes onto schema as specified in nodes, then
+      # creates joins between the sources and targets.  The join class is inferred
+      # by Utils.infer_join; if no join can be inferred the join class is 
+      # effectively nil, and consistent with that, the node output for sources
+      # and the node input for targets is set to nil.
+      #
+      # === Notes
+      #
+      # The nomenclature for source and target is relative to the join, and may
+      # seem backwards for the node (ex: 'sources[]=0&targets[]=1' makes a join
+      # like '0:1')
+      #
+      def add(id)
+        unless request.post?
+          raise Tap::ServerError, "add must be performed with post"
+        end
+    
+        round = (request['round'] || 0).to_i
+        outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
+        inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
+        nodes = request['nodes[]'] || []
+    
+        load_schema(id) do |schema|
+          nodes.each do |arg|
+            next unless arg && !arg.empty?
+
+            outputs << schema.nodes.length
+            schema.nodes << Tap::Support::Node.new(Shellwords.shellwords(arg), round)
+          end
+      
+          if inputs.empty? || outputs.empty?
+            inputs.each {|index| schema[index].output = nil }
+            outputs.each {|index| schema[index].input = round }
+          else
+        
+            # temporary
+            if inputs.length > 1 && outputs.length > 1
+              raise "multi-way join specified"
+            end
+        
+            schema.set(Tap::Support::Join, inputs, outputs)
+          end
+        end
+    
+        redirect("/schema/display/#{id}")
+      end
+  
+      # Removes nodes or joins from the schema.  Parameters:
+      #
+      # sources[]:: An array of source node indicies to remove.
+      # targets[]:: An array of target node indicies to remove.
+      #
+      # Normally remove sets the node.output for each source to nil and the
+      # node.input for each target to nil.  However, if a node is indicated in
+      # both sources and targets AND it has no join input/output, then it will
+      # be removed.
+      #
+      # === Notes
+      #
+      # The nomenclature for source and target is relative to the join, and may
+      # seem backwards for the node (ex: for the sequence '0:1:2', 'targets[]=1'
+      # breaks the join '0:1' while 'sources[]=1' breaks the join '1:2'.
+      #
+      def remove(id)
+        unless request.post?
+          raise Tap::ServerError, "remove must be performed with post"
+        end
+    
+        round = (request['round'] || 0).to_i
+        outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
+        inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
+    
+        load_schema(id) do |schema|
+          # Remove joins.  Removed indicies are popped to ensure
+          # that if a join was removed the node will not be.
+          outputs.delete_if do |index|
+            next unless node = schema.nodes[index]
+            if node.input_join
+              node.input = round
+              true
+            else
+              false
+            end
+          end
+      
+          inputs.delete_if do |index|
+            next unless node = schema.nodes[index]
+            if node.output_join
+              node.output = nil
+              true
+            else
+              false
+            end
+          end
+    
+          # Remove nodes. Setting a node to nil causes it's removal during 
+          # compact; orphaned joins are removed during compact as well.
+          (inputs & outputs).each do |index|
+            schema.nodes[index] = nil
+          end
+        end
+    
+        redirect("/schema/display/#{id}")
+      end
+  
+      def submit(id)
+        case request['action']
+        when 'save'    then save(id)
+        when 'preview' then preview(id)
+        when 'echo'    then echo
+        when 'run'
+          dump_schema(id, schema)
+          run(id)
+        else raise Tap::ServerError, "unknown action: #{request['action']}"
+        end
+      end
+  
+      def save(id)
+        unless request.post?
+          raise Tap::ServerError, "submit must be performed with post"
+        end
+    
+        dump_schema(id, schema)
+        redirect("/schema/display/#{id}")
+      end
+  
+      def preview(id)
+        response.headers['Content-Type'] = 'text/plain'
+        render('preview.erb', :locals => {:id => id, :schema => schema})
+      end
+  
+      def run(id)
+        unless request.post?
+          raise Tap::ServerError, "run must be performed with post"
+        end
+    
+        # it would be nice to someday put all this on a separate thread...
+        schema = load_schema(id)
+        tasks = server.env.tasks
+        schema.build(app) do |(key, *args)|
+          if const = tasks.search(key) 
+            const.constantize.parse(args, app) do |help|
+              raise "help not implemented"
+              #redirect("/app/help/#{key}")
+            end
+          else
+            raise ArgumentError, "unknown task: #{key}"
+          end
+        end
+    
+        Thread.new { app.run }
+        redirect("/app/tail")
+      end
+  
+      protected
+  
+      # Parses a Tap::Support::Schema from the request.
+      def schema
+        argv = request['argv[]'] || []
+        argv.delete_if {|arg| arg.empty? }
+        Tap::Support::Schema.parse(argv)
+      end
+  
+      def initialize_schema
+        current = root.glob(:schema, "*").collect {|path| File.basename(path).chomp(".yml") }
+    
+        id = random_key(current.length)
+        while current.include?(id)
+          id = random_key(current.length)
+        end
+    
+        dump_schema(id, schema)
+        id
+      end
+  
+      def load_schema(id)
+        unless path = root.filepath(:schema, "#{id}.yml")
+          raise ServerError, "no schema for id: #{id}"
+        end
+        schema = Tap::Support::Schema.load_file(path)
+    
+        if block_given?
+          result = yield(schema)
+          dump_schema(id, schema)
+          result
+        else
+          schema
+        end
+      end
+  
+      def dump_schema(id, schema=nil)
+        root.prepare(:schema, "#{id}.yml") do |file|
+          file << YAML.dump(schema.dump) if schema
+        end
+      end
+  
+      def instantiate(*argv)
+        key = argv.shift
+        tasc = server.env.tasks.search(key).constantize 
+        tasc.parse(argv)
+      end
+  
+      # helper to echo requests back... good for debugging
+      def echo # :nodoc:
+        "<pre>#{request.params.to_yaml}</pre>"
+      end
+  
+      # Generates a random integer key.
+      def random_key(length) # :nodoc:
+        length = 1 if length < 1
+        rand(length * 10000).to_s
+      end
+    end
+  end
+end

data/lib/tap/server.rb

@@ -6,16 +6,14 @@ require 'tap/server_error'
 
 module Tap
   Env.manifest(:controllers) do |env|
-    entries = env.root.glob(:controllers, "*_controller.rb").collect do |path|
-      const_name = File.basename(path).chomp('.rb').camelize
-      Support::Constant.new(const_name, path)
-    end
-
-    Support::Manifest.intern(entries) do |manifest, const|
-      const.basename.chomp('_controller')
+    controllers = Support::ConstantManifest.new('controller')
+    env.load_paths.each do |path_root|
+      controllers.register(path_root, '**/*.rb')
     end
+    controllers
   end
   
+  # :::-
   # Server is a Rack application that dispatches calls to other Rack apps, most
   # commonly a Tap::Controller.
   #
@@ -37,24 +35,25 @@ module Tap
   #   req.get('/sample/path/to/resource').body      # => "Sample got /sample : /path/to/resource"
   #
   # Server automatically maps unknown keys to a controller by searching
-  # env.controllers.  As a result '/example' maps to the ExampleController
-  # defined in 'controllers/example_controller.rb'.
+  # env.controllers.  As a result '/example' maps to the Example controller
+  # defined in 'lib/example.rb'.
   #
-  #   # [controllers/example_controller.rb] => %q{
-  #   # class ExampleController
+  #   # [lib/example.rb] => %q{
+  #   # ::controller
+  #   # class Example
   #   #   def self.call(env)
-  #   #     [200, {}, ["ExampleController got #{env['SCRIPT_NAME']} : #{env['PATH_INFO']}"]]
+  #   #     [200, {}, ["Example got #{env['SCRIPT_NAME']} : #{env['PATH_INFO']}"]]
   #   #   end
   #   # end 
   #   # }
   #
-  #   req.get('/example/path/to/resource').body     # => "ExampleController got /example : /path/to/resource"
+  #   req.get('/example/path/to/resource').body     # => "Example got /example : /path/to/resource"
   #
   # If desired, controllers can be set with aliases to map a path key to a
   # lookup key.
   #
   #   server.controllers['sample'] = 'example'
-  #   req.get('/sample/path/to/resource').body      # => "ExampleController got /sample : /path/to/resource"
+  #   req.get('/sample/path/to/resource').body      # => "Example got /sample : /path/to/resource"
   #
   # If no controller can be found, the request is routed using the
   # default_controller_key and the request is NOT adjusted.
@@ -66,6 +65,7 @@ module Tap
   #
   #   req.get('/unknown/path/to/resource').body     # => "App got  : /unknown/path/to/resource"
   #
+  # :::+
   class Server
     include Rack::Utils
     include Configurable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap-server
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-23 00:00:00 -07:00
+date: 2009-03-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.12.2
+        version: 0.12.3
     version: 
 - !ruby/object:Gem::Dependency 
   name: rack
@@ -44,9 +44,9 @@ extra_rdoc_files:
 - History
 files: 
 - cmd/server.rb
-- controllers/app_controller.rb
-- controllers/schema_controller.rb
 - lib/tap/controller.rb
+- lib/tap/controllers/app.rb
+- lib/tap/controllers/schema.rb
 - lib/tap/server.rb
 - lib/tap/server_error.rb
 - lib/tap/tasks/echo.rb
@@ -57,19 +57,19 @@ files:
 - tap.yml
 - views/404.erb
 - views/500.erb
-- views/app_controller/index.erb
-- views/app_controller/info.erb
-- views/app_controller/tail.erb
 - views/layout.erb
-- views/schema_controller/config/default.erb
-- views/schema_controller/config/flag.erb
-- views/schema_controller/config/switch.erb
-- views/schema_controller/configurations.erb
-- views/schema_controller/join.erb
-- views/schema_controller/node.erb
-- views/schema_controller/preview.erb
-- views/schema_controller/round.erb
-- views/schema_controller/schema.erb
+- views/tap/controllers/app/index.erb
+- views/tap/controllers/app/info.erb
+- views/tap/controllers/app/tail.erb
+- views/tap/controllers/schema/config/default.erb
+- views/tap/controllers/schema/config/flag.erb
+- views/tap/controllers/schema/config/switch.erb
+- views/tap/controllers/schema/configurations.erb
+- views/tap/controllers/schema/join.erb
+- views/tap/controllers/schema/node.erb
+- views/tap/controllers/schema/preview.erb
+- views/tap/controllers/schema/round.erb
+- views/tap/controllers/schema/schema.erb
 - views/tap/tasks/echo/result.html
 - README
 - MIT-LICENSE

data/controllers/app_controller.rb

@@ -1,92 +0,0 @@
-require 'tap/controller'
-require 'rack/mime'
-require 'time'
-
-class AppController < Tap::Controller
-  set :default_layout, 'layout.erb'
-  
-  def call(env)
-    # serve public files before actions
-    server = env['tap.server'] ||= Tap::Server.new
-    
-    if path = server.public_path(env['PATH_INFO'])
-      content = File.read(path)
-      headers = {
-        "Last-Modified" => [File.mtime(path).httpdate],
-        "Content-Type" => [Rack::Mime.mime_type(File.extname(path), 'text/plain')], 
-        "Content-Length" => [content.size.to_s]
-      }
-      
-      [200, headers, [content]]
-    else
-      super
-    end
-  end
-  
-  def index
-    env_names = {}
-    server.env.minimap.each do |name, environment|
-      env_names[environment] = name
-    end 
-    
-    render('index.erb', :locals => {:env => server.env, :env_names => env_names}, :layout => true)
-  end
-  
-  def info
-    if request.post?
-      app.info
-    else
-      render('info.erb', :locals => {:update => true, :content => app.info}, :layout => true)
-    end
-  end
-  
-  #--
-  # Currently tail is hard-coded to tail the server log only.
-  def tail(id=nil)
-    begin
-      path = root.subpath(:log, 'server.log')
-      raise unless File.exists?(path)
-    rescue
-      raise Tap::ServerError.new("invalid path", 404)
-    end
-    
-    pos = request['pos'].to_i
-    if pos > File.size(path)
-      raise Tap::ServerError.new("tail position out of range (try update)", 500)
-    end
-
-    content = File.open(path) do |file|
-      file.pos = pos
-      file.read
-    end
-    
-    if request.post?
-      content
-    else
-      render('tail.erb', :locals => {
-        :id => id,
-        :path => File.basename(path),
-        :update => true,
-        :content => content
-      }, :layout => true)
-    end
-  end
-  
-  def run
-    Thread.new { app.run }
-    redirect("/app/tail")
-  end
-  
-  def stop
-    app.stop
-    redirect("/app/info")
-  end
-  
-  def terminate
-    app.terminate
-    redirect("/app/info")
-  end
-  
-  def help(key=nil)
-  end
-end

data/controllers/schema_controller.rb

@@ -1,255 +0,0 @@
-require 'tap/controller'
-
-class SchemaController < Tap::Controller
-  set :default_layout, 'layout.erb'
-  
-  # Initializes a new schema and redirects to display.
-  def index
-    id = initialize_schema
-    redirect("/schema/display/#{id}")
-  end
-  
-  # Loads the schema indicated by id and renders 'schema.erb' with the default
-  # layout.
-  def display(id)
-    schema = load_schema(id)
-    render 'schema.erb', :locals => {
-      :id => id, 
-      :schema => schema
-    }, :layout => true
-  end
-  
-  # Updates the specified schema with the request parameters.  Update forwards
-  # the request to the action ('add' or 'remove') specified in the action
-  # parameter.
-  def update(id)
-    case request['action']
-    when 'add'    then add(id)
-    when 'remove' then remove(id)
-    when 'echo'   then echo
-    else raise Tap::ServerError, "unknown action: #{request['action']}"
-    end
-  end
-  
-  # Adds nodes or joins to the schema.  Parameters:
-  #
-  # nodes[]:: An array of nodes to add to the schema. Each entry is split using
-  #           Shellwords to yield an argv; the argv initializes the node.  The
-  #           index of each new node is added to targets[].
-  # sources[]:: An array of source node indicies used to create a join.
-  # targets[]:: An array of target node indicies used to create a join (note
-  #             the indicies of new nodes are added to targets).
-  #
-  # Add creates and pushes new nodes onto schema as specified in nodes, then
-  # creates joins between the sources and targets.  The join class is inferred
-  # by Utils.infer_join; if no join can be inferred the join class is 
-  # effectively nil, and consistent with that, the node output for sources
-  # and the node input for targets is set to nil.
-  #
-  # === Notes
-  #
-  # The nomenclature for source and target is relative to the join, and may
-  # seem backwards for the node (ex: 'sources[]=0&targets[]=1' makes a join
-  # like '0:1')
-  #
-  def add(id)
-    unless request.post?
-      raise Tap::ServerError, "add must be performed with post"
-    end
-    
-    round = (request['round'] || 0).to_i
-    outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
-    inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
-    nodes = request['nodes[]'] || []
-    
-    load_schema(id) do |schema|
-      nodes.each do |arg|
-        next unless arg && !arg.empty?
-
-        outputs << schema.nodes.length
-        schema.nodes << Tap::Support::Node.new(Shellwords.shellwords(arg), round)
-      end
-      
-      if inputs.empty? || outputs.empty?
-        inputs.each {|index| schema[index].output = nil }
-        outputs.each {|index| schema[index].input = round }
-      else
-        
-        # temporary
-        if inputs.length > 1 && outputs.length > 1
-          raise "multi-way join specified"
-        end
-        
-        schema.set(Tap::Support::Join, inputs, outputs)
-      end
-    end
-    
-    redirect("/schema/display/#{id}")
-  end
-  
-  # Removes nodes or joins from the schema.  Parameters:
-  #
-  # sources[]:: An array of source node indicies to remove.
-  # targets[]:: An array of target node indicies to remove.
-  #
-  # Normally remove sets the node.output for each source to nil and the
-  # node.input for each target to nil.  However, if a node is indicated in
-  # both sources and targets AND it has no join input/output, then it will
-  # be removed.
-  #
-  # === Notes
-  #
-  # The nomenclature for source and target is relative to the join, and may
-  # seem backwards for the node (ex: for the sequence '0:1:2', 'targets[]=1'
-  # breaks the join '0:1' while 'sources[]=1' breaks the join '1:2'.
-  #
-  def remove(id)
-    unless request.post?
-      raise Tap::ServerError, "remove must be performed with post"
-    end
-    
-    round = (request['round'] || 0).to_i
-    outputs = (request['outputs[]'] || []).collect {|index| index.to_i }
-    inputs = (request['inputs[]'] || []).collect {|index| index.to_i }
-    
-    load_schema(id) do |schema|
-      # Remove joins.  Removed indicies are popped to ensure
-      # that if a join was removed the node will not be.
-      outputs.delete_if do |index|
-        next unless node = schema.nodes[index]
-        if node.input_join
-          node.input = round
-          true
-        else
-          false
-        end
-      end
-      
-      inputs.delete_if do |index|
-        next unless node = schema.nodes[index]
-        if node.output_join
-          node.output = nil
-          true
-        else
-          false
-        end
-      end
-    
-      # Remove nodes. Setting a node to nil causes it's removal during 
-      # compact; orphaned joins are removed during compact as well.
-      (inputs & outputs).each do |index|
-        schema.nodes[index] = nil
-      end
-    end
-    
-    redirect("/schema/display/#{id}")
-  end
-  
-  def submit(id)
-    case request['action']
-    when 'save'    then save(id)
-    when 'preview' then preview(id)
-    when 'echo'    then echo
-    when 'run'
-      dump_schema(id, schema)
-      run(id)
-    else raise Tap::ServerError, "unknown action: #{request['action']}"
-    end
-  end
-  
-  def save(id)
-    unless request.post?
-      raise Tap::ServerError, "submit must be performed with post"
-    end
-    
-    dump_schema(id, schema)
-    redirect("/schema/display/#{id}")
-  end
-  
-  def preview(id)
-    response.headers['Content-Type'] = 'text/plain'
-    render('preview.erb', :locals => {:id => id, :schema => schema})
-  end
-  
-  def run(id)
-    unless request.post?
-      raise Tap::ServerError, "run must be performed with post"
-    end
-    
-    # it would be nice to someday put all this on a separate thread...
-    schema = load_schema(id)
-    tasks = server.env.tasks
-    schema.build(app) do |(key, *args)|
-      if const = tasks.search(key) 
-        const.constantize.parse(args, app) do |help|
-          raise "help not implemented"
-          #redirect("/app/help/#{key}")
-        end
-      else
-        raise ArgumentError, "unknown task: #{key}"
-      end
-    end
-    
-    Thread.new { app.run }
-    redirect("/app/tail")
-  end
-  
-  protected
-  
-  # Parses a Tap::Support::Schema from the request.
-  def schema
-    argv = request['argv[]'] || []
-    argv.delete_if {|arg| arg.empty? }
-    Tap::Support::Schema.parse(argv)
-  end
-  
-  def initialize_schema
-    current = root.glob(:schema, "*").collect {|path| File.basename(path).chomp(".yml") }
-    
-    id = random_key(current.length)
-    while current.include?(id)
-      id = random_key(current.length)
-    end
-    
-    dump_schema(id, schema)
-    id
-  end
-  
-  def load_schema(id)
-    unless path = root.filepath(:schema, "#{id}.yml")
-      raise ServerError, "no schema for id: #{id}"
-    end
-    schema = Tap::Support::Schema.load_file(path)
-    
-    if block_given?
-      result = yield(schema)
-      dump_schema(id, schema)
-      result
-    else
-      schema
-    end
-  end
-  
-  def dump_schema(id, schema=nil)
-    root.prepare(:schema, "#{id}.yml") do |file|
-      file << YAML.dump(schema.dump) if schema
-    end
-  end
-  
-  def instantiate(*argv)
-    key = argv.shift
-    tasc = server.env.tasks.search(key).constantize 
-    tasc.parse(argv)
-  end
-  
-  # helper to echo requests back... good for debugging
-  def echo # :nodoc:
-    "<pre>#{request.params.to_yaml}</pre>"
-  end
-  
-  # Generates a random integer key.
-  def random_key(length) # :nodoc:
-    length = 1 if length < 1
-    rand(length * 10000).to_s
-  end
-end