tap-server 0.5.0 → 0.6.0

data/lib/tap/controllers/data.rb

@@ -61,6 +61,7 @@ module Tap
       # POST /projects?_method=put&id=id
       def destroy(id)
         data.destroy(type, id)
+        deselect([id])
         redirect uri
       end
       
@@ -72,7 +73,21 @@ module Tap
       end
       
       def select(ids=[])
-        data.cache[type] = ids
+        current = data.cache[type] ||= []
+        data.cache[type] = current | ids
+        redirect uri
+      end
+      
+      def deselect(ids=[])
+        if current = data.cache[type]
+          data.cache[type] = current - ids
+        end
+        redirect uri
+      end
+      
+      def destroy_all(ids=[])
+        ids.each {|id| data.destroy(type, id) }
+        deselect(ids)
         redirect uri
       end
       

data/lib/tap/controllers/server.rb

@@ -16,7 +16,24 @@ module Tap
       include Utils
       
       def index
-        render('index.erb', :layout => true)
+        env = server.env
+        env_keys = env.minihash(true) 
+        constants = env.constants
+        manifests = env.collect do |current|
+          types = {}
+          constants.entries(current).minimap.each do |key, const|
+            const.types.keys.each do |type|
+              (types[type] ||= []) << [key, const]
+            end
+          end
+          
+          types = types.to_a.sort_by {|type, minimap| type }
+          types.empty? ? nil : [env_keys[current], types]
+        end 
+        
+        render 'index.erb', :locals => {
+          :manifests => manifests.compact
+        }, :layout => true
       end
       
       # Returns pong
@@ -55,11 +72,12 @@ module Tap
         end
       end
       
-      def help(type=nil, *key)
-        if constant = server.env[type][key.join('/')]
-          module_render 'help.erb', constant
+      def help(*key)
+        if constant = server.env[key.join('/')]
+          path = server.module_path('help.erb', constant)
+          render :file => path, :locals => {:obj => constant}
         else
-          "unknown #{type}: #{key.join('/')}"
+          "unknown constant: #{key.join('/')}"
         end
       end
       
@@ -67,11 +85,31 @@ module Tap
       set :define_action, false
       
       def call(rack_env)
-        path = rack_env['tap.server'].env.path(:public, rack_env['PATH_INFO']) {|file| File.file?(file) }
-        if path
-          static_file(path)
+        server = rack_env['tap.server']
+        env = server ? server.env : nil
+        path_info = rack_env['PATH_INFO']
+        
+        # serve static files
+        path = env.path(:public, path_info) {|file| File.file?(file) }
+        return static_file(path) if path
+        
+        # route to a controller
+        blank, path, path_info = path_info.split("/", 3)
+        constant = env ? env.constants.seek(unescape(path)) : nil
+
+        if constant
+          # adjust rack_env if route routes to a controller
+          rack_env['SCRIPT_NAME'] = "#{rack_env['SCRIPT_NAME'].chomp('/')}/#{path}"
+          rack_env['PATH_INFO'] = "/#{path_info}"
+
+          constant.unload if server.development
+          controller = constant.constantize
+          controller == Server ? super : controller.call(rack_env)
         else
-          super
+          response = Rack::Response.new
+          response.status = 302
+          response['Location'] = ["/server#{rack_env['PATH_INFO']}".chomp("/")]
+          response.finish
         end
       end
       
@@ -87,15 +125,20 @@ module Tap
       end
       
       # Returns a help uri for the specified resource, currently only sketched out.
-      def help_uri(type, key)
-        uri("help/#{type}/#{key}")
+      def help_uri(key)
+        uri("help/#{key}")
       end
       
-      # Stops the server.
-      def stop!
-        server.stop!
+      def template
+        %Q{<% if !minimap.empty? && count > 1 %>
+  <h2><%= env_key %></h2>
+  <li>
+    <ul><% minimap.each do |key, entry| %>
+    <li><%= key %> (<a href="help/<%= key %>">?</a>)</li><% end %>
+    </ul>
+  </li>
+<% end %>}
       end
-      
     end
   end
 end

data/lib/tap/generator/generators/controller.rb

@@ -0,0 +1,23 @@
+require 'tap/generator/generators/resource'
+
+module Tap
+  module Generator
+    module Generators
+      # :startdoc::generator generates a controller
+      #
+      # Generates a new Tap::Controller and an associated test file.
+      class Controller < Resource
+        
+        def manifest(m, const_name)
+          const = super
+          
+          views_dir = path('views', "#{const.path}")
+          m.directory File.dirname(views_dir)
+          m.template path(views_dir, "index.erb"), "view.erb"
+          
+          const
+        end
+      end 
+    end
+  end
+end

data/lib/tap/server.rb

@@ -1,12 +1,20 @@
+require 'rack'
 require 'tap'
 require 'tap/server/data'
-require 'tap/server/runner'
 require 'tap/server/server_error'
 
 module Tap
   # ::configurable
   class Server
-    include Runner
+    include Rack::Utils
+    include Configurable
+
+    config :servers, %w[thin mongrel webrick],      # the server handlers
+      :long => :server, 
+      &c.list 
+  
+    config :host, '127.0.0.1', &c.string            # the server host
+    config :port, 8080, &c.integer_or_nil           # the server port
     
     # Server implements a secret for HTTP administration of the server (ex
     # remote shutdown). Under many circumstances this functionality is
@@ -16,22 +24,34 @@ module Tap
     
     config :development, false, &c.flag
     
-    config :router, true, &c.switch
-    
-    nest :env, Tap::Env, :type => :hidden
-    
-    nest :app, Tap::App, :type => :hidden
-    
     nest :data, Data, :type => :hidden
     
-    attr_accessor :controller
+    attr_reader :app
+    attr_reader :controller
     
-    attr_accessor :thread
+    def initialize(config={}, app=Tap::App.instance, &block)
+      @handler = nil
+      @controller = block
+      
+      @app = app
+      initialize_config(config)
+    end
+    
+    def env
+      app.env
+    end
     
-    def initialize(controller=nil, config={})
+    def bind(controller)
+      if controller.kind_of?(String)
+        controller = app.resolve(controller)
+      end
+      
+      unless controller.respond_to?(:call)
+        raise "invalid controller: #{controller.inspect}"
+      end
+      
       @controller = controller
-      @thread = nil
-      super(config)
+      self
     end
     
     # Returns true if input is equal to the secret, if a secret is set. Used
@@ -41,36 +61,18 @@ module Tap
       secret != nil && input == secret
     end
     
-    def route(rack_env)
-      return controller unless router
-      
-      # route to a controller
-      blank, path, path_info = rack_env['PATH_INFO'].split("/", 3)
-      controller = lookup_controller(unescape(path))
-      
-      if controller
-        # adjust rack_env if route routes to a controller
-        rack_env['SCRIPT_NAME'] = ["#{rack_env['SCRIPT_NAME'].chomp('/')}/#{path}"]
-        rack_env['PATH_INFO'] = ["/#{path_info}"]
-      else
-        # use default controller
-        controller = self.controller
-        path = nil
-      end
-      
-      rack_env['tap.controller_path'] = path
-      controller
+    def template_path(path)
+      app.env.path(:views, path) {|file| File.file?(file) }
     end
-
+    
+    def module_path(path, klass)
+      app.env.module_path(:views, klass.ancestors, path) {|file| File.file?(file) }
+    end
+    
     # The {Rack}[http://rack.rubyforge.org/doc/] interface method.
     def call(rack_env)
       # handle the request
       rack_env['tap.server'] = self
-      
-      unless controller = route(rack_env)
-        raise ServerError.new("404 Error: could not route to controller", 404)
-      end
-      
       controller.call(rack_env)
     rescue ServerError
       $!.response
@@ -78,27 +80,47 @@ module Tap
       ServerError.response($!)
     end
     
-    def run!
-      super(self)
+    # Runs self as configured, on the specified server, host, and port.  Use an
+    # INT signal to interrupt.
+    def run!(handler=rack_handler)
+      return self if @handler
+    
+      handler.run(self, :Host => host, :Port => port) do |handler|
+        @handler = handler
+        trap(:INT) { stop! }
+        yield if block_given?
+      end
+    
+      self
+    end
+
+    # Stops the server if running (ie a handler is set).
+    def stop!
+      if @handler
+        # Use thins' hard #stop! if available, otherwise just #stop
+        @handler.respond_to?(:stop!) ? @handler.stop! : @handler.stop
+        @handler = nil
+      
+        yield if block_given?
+      end
+    
+      self
     end
     
     protected
     
-    def lookup_controller(key) # :nodoc:
-      if development
-        # unload the controller in development mode so that
-        # controllers will be reloaded each request
-          
-        env.reset
-        if const = env.seek(:controller, key)
-          const.unload
-          const.constantize
-        else
-          nil
+    # Looks up and returns the first available Rack::Handler as listed in the
+    # servers configuration. (Note rack_handler returns a handler class, not
+    # an instance).  Adapted from Sinatra.detect_rack_handler
+    def rack_handler # :nodoc:
+      servers.each do |server_name|
+        begin
+          return Rack::Handler.get(server_name)
+        rescue LoadError
+        rescue NameError
         end
-      else
-        env[:controller][key]
       end
+      raise "Server handler (#{servers.join(',')}) not found."
     end
   end
 end

data/lib/tap/tasks/echo.rb

@@ -15,7 +15,7 @@ module Tap
       #config :sym, :sym, &c.symbol           # sym
       config :integer, 10, &c.integer        # integer
       config :numeric, 10, &c.numeric        # numeric
-      config :float, 10, &c.float            # float
+      config :float, 10.0, &c.float            # float
       
       config :string_or_nil, nil, &c.string_or_nil   # string_or_nil (nil)
       #config :sym_or_nil, nil, &c.symbol_or_nil      # symbol_or_nil (nil)

data/templates/tap/generator/generators/controller/resource.erb

@@ -0,0 +1,14 @@
+require 'tap/controller'
+
+<% redirect do |target| %># :startdoc::controller <replace with summary>
+# <replace with description>
+
+# <%= const.name %> Documentation
+class <%= const.name %> < Tap::Controller
+
+  # Methods define actions on the controller
+  def index
+    render 'index.erb', :locals => {:obj => 'moon'}, :layout => true
+  end
+  
+end <% module_nest(const.nesting, '  ') { target } end %>

data/templates/tap/generator/generators/controller/view.erb

@@ -0,0 +1 @@
+Goodnight <%%= obj %>!

data/views/configurable/configurations.erb

@@ -0,0 +1,57 @@
+<dl>
+<% configurations.each_pair do |key, config|  %>
+<%  next if config[:type] == :hidden %>
+<%  name = "#{name_base}[#{key.inspect}]" %>
+<%  value = values[key] %>
+
+<%  if config.is_nest? %>
+  <dt class="name"><%= key %></dt>
+  <dd class="nested-configs">
+<%=   module_render("configurations.erb", obj, :locals => {
+        :name_base => name,
+        :configurations => config.default(false).delegates, 
+        :values => value
+      }) %>
+  </dd>
+<%    next %>  
+<%  end %>
+
+  <dt><%= key %></dt>
+  <dd>
+<%  case config[:type] %>
+<%  when :flag %>
+  <input name="<%= name %>" type="hidden" value="false" />
+  <input name="<%= name %>" type="checkbox" value="true" <%= value ? 'checked="true"' : '' %> />
+  
+<%  when :switch %>
+  <input name="<%= name %>" type="radio" value="true"  <%= value  ? 'checked="true" ' : '' %>>on</input>
+  <input name="<%= name %>" type="radio" value="false" <%= !value ? 'checked="true" ' : '' %>>off</input>
+  
+<%  when :select %>
+  <select name="<%= name %>">
+  <% (config[:options] || []).each do |option| %>
+    <option value="<%= option %>" <%= value == option ? "selected='true' " : ""%>><%= option %></option>
+  <% end %>
+  </select>
+  
+<%  when :list_select %>
+  <input type="hidden" name="<%= name %>[]" value="#" />
+  <select name="<%= name %>[]" multiple="true">
+  <% (config[:options] || []).each do |option| %>
+    <option value="<%= option %>" <%= value && value.include?(option) ? "selected='true' " : ""%>><%= option %></option>
+  <% end %>
+  </select>
+
+<%  when :hidden %>
+<%    next %>
+<%  else %>
+<%=   render(
+        :file =>  module_path("#{config[:type]}.erb", obj.class) || template_path("configurable/default.erb"), 
+        :locals => {
+          :name => name,
+          :config => config,
+          :value => value}) %>    
+<%  end %>
+  </dd>
+<% end %>
+</dl>

data/views/configurable/default.erb

@@ -0,0 +1 @@
+<input name="<%= name %>" type="text" value="<%= value %>" />

data/views/layout.erb

@@ -2,10 +2,13 @@
 <head>
 <title>Tap (Server)</title>
 <link rel="stylesheet" type="text/css" href="/stylesheets/tap.css" />
-<script src="/javascripts/prototype.js"></script>
-<script src="/javascripts/tap.js"></script>
+<!-- <script src="/javascripts/tap.js"></script> -->
 </head>
 <body>
 <%= content %>
+
+<ul>
+  <li><a href="/">Home</a></li>
+</ul>
 </body>
 </html>

data/views/tap/{task → app/api}/help.erb

@@ -2,16 +2,18 @@
 
 <ul>
 <li class="source_file">
-  <h2>Source File</h2>
-  <p><%= obj.source_file %><p>
+  <h2>Registered As</h2>
+  <ul><% Lazydoc::Document[obj.to_s].each_pair do |type, comment| %>
+  <li><%= type %> (<%= comment.document.source_file %>)</li><% end %>
+  </ul>
 </li>
 <li>
   <h2>Summary</h2>
-  <%= obj.desc.subject %>
+  <%= obj.desc ? obj.desc.subject : nil %>
 </li>
 <li>
   <h2>Documentation</h2>
-  <pre class="desc"><%= obj.desc.wrap %></pre>
+  <pre class="desc"><%= obj.desc ? obj.desc.wrap : nil %></pre>
 </li>
 <li>
   <h2>Signature</h2>