tap-server 0.3.0 → 0.4.0

data/History

@@ -1,3 +1,8 @@
+== 0.4.0 / 2009-05-25
+
+Significant internal rework to utilize Tap-0.17.0.
+Tap-Server should still be considered experimental.
+
 == 0.3.0 / 2009-03-17
 
 Significant updates.

data/cmd/server.rb

@@ -1,26 +1,54 @@
-# tap server {options}
+# tap server {options} 
 #
 # Initializes a tap server.
+#
 
 require 'tap'
 require 'tap/server'
 
 env = Tap::Env.instance
 app = Tap::App.instance
-parser = ConfigParser.new do |opts|
+
+begin
+  opts = ConfigParser.new('env' => env, 'app' => app)
+  opts.separator ""
+  opts.separator "configurations:"
+  opts.add(Tap::Server.configurations)
   
   opts.separator ""
   opts.separator "options:"
-  opts.add(Tap::Server.configurations)
-
-  # add option to print help
+  
+  opts.on('--config FILE', 'Specifies a config file') do |config_file|
+    opts.config.merge! Configurable::Utils.load_file(config_file)
+  end
+  
   opts.on("-h", "--help", "Show this message") do
     puts Lazydoc.usage(__FILE__)
     puts opts
     exit
   end
+  
+  # (note defaults are not added so they will not
+  # conflict with string keys from a config file)
+  args = opts.parse!(ARGV, :clear_config => false, :add_defaults => false)
+  
+  if args.empty?
+    args << 'server'
+  end
+  
+  controller = env[:controller][args.shift]
+  
+  unless args.empty?
+    warn "ignoring args: #{args.inspect}"
+  end
+  
+  Tap::Server.new(controller, opts.nested_config).run!
+rescue
+  raise if $DEBUG
+  puts $!.message
+  exit(1)
 end
-argv = parser.parse(ARGV)
 
-# launch server
-Tap::Server.new(env, app, parser.config).run!
+exit(0)
+
+

data/lib/tap/controller/rest_routes.rb

@@ -0,0 +1,77 @@
+module Tap
+  class Controller
+    # Adds REST routing to a Tap::Controller.
+    #
+    #   class Projects < Tap::Controller
+    #     include RestRoutes
+    #
+    #     # GET /projects
+    #     def index...
+    # 
+    #     # GET /projects/*args
+    #     def show(*args)...
+    #
+    #     # POST /projects/*args
+    #     def create(*args)...
+    # 
+    #     # PUT /projects/*args
+    #     # POST /projects/*args?_method=put
+    #     def update(*args)...
+    # 
+    #     # DELETE /projects/*args
+    #     # POST /projects/*args?_method=delete
+    #     def destroy(*args)...
+    #
+    #     # extension...
+    #
+    #     # POST /projects/*args?_method=another
+    #     def another(*args)...
+    #   end
+    #
+    # === Relation to RESTful Rails
+    #
+    # Unlike the REST syntax in Rails, '/projects/new' is treated like a show
+    # where the id is 'new'.  Also missing is the routing for urls like
+    # '/projects/arg;edit/'. See these resources:
+    #
+    # * {RESTful Rails Development}[http://www.b-simple.de/download/restful_rails_en.pdf]
+    # * {REST cheatsheet}[topfunky.com/clients/peepcode/REST-cheatsheet.pdf]
+    #
+    module RestRoutes
+      def route
+        blank, *route = request.path_info.split("/").collect {|arg| unescape(arg) }
+        route.unshift rest_action(route)
+        route
+      end
+      
+      def rest_action(args)
+        case request.request_method
+        when /GET/i
+          if args.empty?
+            :index
+          else
+            :show
+          end
+        when /POST/i
+          case _method = request[:_method]
+          when /put/i  
+            :update
+          when /delete/i  
+            :destroy
+          when nil
+            :create
+          else 
+            if action?(_method)
+              _method
+            else
+              raise Server::ServerError.new("unknown post method: #{_method}")
+            end
+          end
+        when /PUT/i  then :update
+        when /DELETE/i then :destroy
+        else raise Server::ServerError.new("unknown request method: #{request.request_method}")
+        end
+      end
+    end
+  end
+end

data/lib/tap/controller/utils.rb

@@ -0,0 +1,29 @@
+module Tap
+  class Controller
+    module Utils
+      
+      def static_file(path)
+        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]]
+      end
+      
+      def download(path)
+        content = File.read(path)
+        headers = {
+          "Last-Modified" => File.mtime(path).httpdate,
+          "Content-Type" => Rack::Mime.mime_type(File.extname(path), 'text/plain'), 
+          "Content-Disposition" => "attachment; filename=#{File.basename(path)};",
+          "Content-Length" => content.size.to_s
+        }
+    
+        [200, headers, [content]]
+      end
+    end
+  end
+end

data/lib/tap/controller.rb

@@ -1,10 +1,12 @@
+require 'erb'
 require 'tap/server'
-require 'tap/support/persistence'
-autoload(:ERB, 'erb')
+require 'tap/controller/rest_routes'
+require 'tap/controller/utils'
 
 module Tap
   
   # === Declaring Actions
+  #
   # By default all public methods in subclasses are declared as actions.  You
   # can declare a private or protected method as an action by:
   #
@@ -17,119 +19,112 @@ module Tap
   # * define it private or protected then call public(:method)
   #
   class Controller
-    
-    # Adds REST routing (a-la Rails[http://www.b-simple.de/download/restful_rails_en.pdf])
-    # to a Tap::Controller.
-    #
-    #   class Projects < Tap::Controller
-    #     include RestRoutes
-    #
-    #     # GET /projects
-    #     def index...
-    # 
-    #     # GET /projects/*args
-    #     def show(*args)...
-    # 
-    #     # GET /projects/arg;edit/*args
-    #     def edit(arg, *args)...
-    #
-    #     # POST /projects/*args
-    #     def create(*args)...
-    # 
-    #     # PUT /projects/*args
-    #     def update(*args)...
-    # 
-    #     # DELETE /projects/*args
-    #     def destroy(*args)...
-    #   end
-    #
-    module RestRoutes
-      def route
-        blank, *args = request.path_info.split("/").collect {|arg| unescape(arg) }
-        action = case request.request_method
-        when /GET/i  
-          case
-          when args.empty?
-            :index
-          when args[0] =~ /(.*);edit$/
-            args[0] = $1
-            :edit
-          else 
-            :show
-          end
-        when /POST/i then :create
-        when /PUT/i  then :update
-        when /DELETE/i then :destroy
-        else raise ServerError.new("unknown request method: #{request.request_method}")
-        end
-
-        [action, args]
-      end
-    end
-        
     class << self
-      
+
       # Initialize instance variables on the child and inherit as necessary.
       def inherited(child) # :nodoc:
         super
+        
+        unless child.instance_variable_defined?(:@source_file)
+          caller[0] =~ Lazydoc::CALLER_REGEXP
+          child.instance_variable_set(:@source_file, File.expand_path($1)) 
+        end
+        
+        set_variables.each do |variable|
+          child.set(variable, get(variable))
+        end
+        
         child.set(:actions, actions.dup)
-        child.set(:default_layout, default_layout)
         child.set(:define_action, true)
       end
-      
+
       # An array of methods that can be called as actions.  Actions must be
       # stored as symbols.  Actions are inherited.
       attr_reader :actions
-      
-      # The default layout rendered when the render option :layout is true.
-      attr_reader :default_layout
-      
-      # The base path prepended to render paths (ie render(<path>) renders
-      # <templates_dir/name/path>).
-      def name
-        @name ||= to_s.underscore
-      end
+
+      # The default action called for the request path '/'
+      attr_reader :default_action
       
       # Instantiates self and performs call.
       def call(env)
         new.call(env)
       end
-      
-      # Sets an instance variable for self, short for:
+
+      # Sets an instance variable for self (ie the class), short for:
       #
       #   instance_variable_set(:@attribute, input)
       #
-      # Typically only these variables should be set:
+      # These variables are meaningful to a default Tap::Controller and will
+      # be inherited by subclasses:
       #
       #   actions:: sets actions
-      #   name:: the name of the controller
-      #   default_layout:: the default layout (used by render)
+      #   default_action:: the default action (:index)
       #
       def set(variable, input)
+        set_variables << variable
         instance_variable_set("@#{variable}", input)
       end
       
-      protected
+      # Gets the value of an instance variable set via set.  Returns nil for
+      # variables that have not been set through set.
+      def get(variable)
+        return nil unless set_variables.include?(variable)
+        instance_variable_get("@#{variable}")
+      end
       
+      # An array of variables set via set.  set_variables are inherited.
+      def set_variables
+        @set_variables ||= []
+      end
+      
+      def nest(key, controller, &block)
+        
+        # generate a subclass if anything gets overridden
+        if block_given?
+          controller = Class.new(controller)
+          controller.class_eval(&block)
+        end
+        
+        # this check prevents a warning in cases where the nesting 
+        # class defines the nested class
+        const_name = key.to_s.camelize
+        unless const_defined?(const_name) && const_get(const_name) == subclass
+          const_set(const_name, controller)
+        end
+        
+        define_method(key) do |*args|
+          instance = controller.new
+          
+          instance.server = server
+          instance.controller_path = controller_path ? "#{controller_path}/#{key}" : key
+          instance.request = request
+          instance.response = response
+          
+          instance.dispatch(args)
+        end
+      end
+
+      protected
+
       # Overridden so that if declare_action is set, new methods
       # are added to actions.
       def method_added(sym) # :nodoc:
         actions << sym if @define_action
         super
       end
-      
+
       # Turns on declare_action when changing method context.
       def public(*symbols) # :nodoc:
         @define_action = true if symbols.empty?
         super
       end
-      
+
       # Turns off declare_action when changing method context.
       def protected(*symbols) # :nodoc:
         @define_action = false if symbols.empty?
         super
       end
-      
+
       # Turns off declare_action when changing method context.
       def private(*symbols) # :nodoc:
         @define_action = false if symbols.empty?
@@ -137,107 +132,234 @@ module Tap
       end
     end
     
+    extend Lazydoc::Attributes
+    include Rack::Utils
+    ServerError = Tap::Server::ServerError
+    
+    lazy_attr :desc, 'controller'
+    
     set :actions, []
-    set :default_layout, nil
+    set :default_action, :index
+    set :default_layout, 'layout.erb'
     
+    #--
     # Ensures methods (even public methods) on Controller will
     # not be actions in subclasses. 
     set :define_action, false
     
-    include Rack::Utils
-    
-    # Accesses the 'tap.server' specified in env, set during call.
     attr_accessor :server
     
+    attr_accessor :controller_path
+    
     # A Rack::Request wrapping env, set during call.
     attr_accessor :request
-    
+
     # A Rack::Response.  If the action returns a string, it will be written to
     # response and response will be returned by call.  Otherwise, call returns
     # the action result and response is ignored.
     attr_accessor :response
     
-    # The action currently being called by self.
-    attr_accessor :action
+    # Initializes a new instance of self.
+    def initialize
+      @request = @response = @server = @controller_path = nil
+    end
+    
+    # Returns true if action is registered as an action for self.
+    def action?(action)
+      self.class.actions.include?(action.to_sym)
+    end
+    
+    # Returns a uri to the specified action on self.
+    def uri(action=nil, params={})
+      uri = []
+      
+      if controller_path
+        uri << '/'
+        uri << controller_path
+      end
+      
+      if action
+        uri << '/'
+        uri << action
+      end
+      
+      unless params.empty?
+        uri << '?'
+        uri << build_query(params)
+      end
+      
+      uri.join
+    end
+    
+    def template_path(path)
+      server.env.path(:views, path) {|file| File.file?(file) }
+    end
     
-    # Initializes a new instance of self.  The input attributes are reset by
-    # call and are only provided for convenience during testing.
-    def initialize(server=nil, request=nil, response=nil)
-      @server = server
-      @request = request
-      @response = response
-      @action = nil
+    def module_path(path, klass=self.class)
+      server.env.module_path(:views, klass.ancestors, path) {|file| File.file?(file) }
     end
     
+    # Routes the request to an action and returns the response.  Routing is
+    # simple and fixed (see route):
+    #
+    #   route                  calls
+    #   /                      default_action (ie 'index')
+    #   /action/*args          action(*args)
+    #
+    # If the action returns a string, it will be written to response.
+    # Otherwise, call returns the result of action.  This allows actions like:
+    #
+    #   class ActionsController < Tap::Controller
+    #     def simple
+    #       "html body"
+    #     end
+    #
+    #     def standard
+    #       response["Content-Type"] = "text/plain"
+    #       response << "text"
+    #       response.finish
+    #     end
+    #
+    #     def custom
+    #       [200, {"Content-Type" => "text/plain"}, ["text"]]
+    #     end
+    #   end
+    #
     def call(env)
-      @server = env['tap.server'] || Tap::Server.new
+      @server = env['tap.server']
+      @controller_path = env['tap.controller_path']
+      
       @request = Rack::Request.new(env)
       @response = Rack::Response.new
       
-      # route to an action
-      @action, args = route
-      unless self.class.actions.include?(@action)
-        raise ServerError.new("404 Error: page not found", 404)
-      end
-      
-      result = send(@action, *args)
-      if result.kind_of?(String) 
+      case result = dispatch(route)
+      when String
         response.write result
         response.finish
+      when nil
+        response.finish
       else 
         result
       end
     end
-    
+
+    # Returns the action, args, and extname for the request.path_info.  Routing
+    # is simple and fixed:
+    #
+    #   route             returns
+    #   /                 [:index, []]
+    #   /action/*args     [:action, args]
+    #
+    # The action and args are unescaped by route.  An alternate default action
+    # may be specified using set.  Override this method in subclasses for
+    # fancier routes.
     def route
-      blank, action, *args = request.path_info.split("/").collect {|arg| unescape(arg) }
-      action = "index" if action == nil || action.empty?
-      action = action.chomp(File.extname(action)).to_sym
+      blank, *route = request.path_info.split("/").collect {|arg| unescape(arg) }
+      route
+    end
+    
+    def dispatch(route)
+      action, *args = route
+      
+      if action == nil || action == ""
+        action = self.class.default_action 
+      end
       
-      [action, args]
+      unless action?(action)
+        raise ServerError.new("404 Error: page not found", 404)
+      end
+      
+      send(action, *args)
     end
     
+    # Renders the class_file at path with the specified options.  Path can be
+    # omitted if options specifies an alternate path to render.  Options:
+    #
+    #   template:: renders the template relative to the template directory
+    #   file:: renders the specified file 
+    #   layout:: renders with the specified layout, or default_layout if true
+    #   locals:: a hash of local variables used in the template
+    #
     def render(path, options={})
       options, path = path, nil if path.kind_of?(Hash)
-      
+
       # lookup template
       template_path = case
-      when options.has_key?(:template)
-        server.search(:views, options[:template])
+      when options[:file]
+        options[:file]
+      when options[:template]
+        self.template_path(options[:template])
       else
-        server.search(:views, "#{self.class.name}/#{path}")
+        self.module_path(path)
       end
-      
+
       unless template_path
-        raise "could not find template for: #{path}"
+        raise "could not find template: (path: #{path.inspect}, file: #{options[:file].inspect}, template: #{options[:template].inspect})"
       end
       
       # render template
       template = File.read(template_path)
-      content = render_erb(template, options)
+      content = render_erb(template, options, template_path)
       
       # render layout
-      layout = options[:layout]
-      layout = self.class.default_layout if layout == true
-      if layout
-        render(:template => layout, :locals => {:content => content})
+      render_layout(options[:layout], content)
+    end
+
+    # Renders the specified layout with content as a local variable.  If layout
+    # is true, the class default_layout will be rendered. Returns content if no
+    # layout is specified.
+    def render_layout(layout, content)
+      return content unless layout
+      
+      if layout == true
+        layout = self.class.get(:default_layout)
+      end
+      
+      if layout.kind_of?(Hash)
+        locals = layout[:locals] ||= {}
+        
+        if locals.has_key?(:content)
+          raise "layout already has local content assigned: #{layout.inspect}"
+        end
+        
+        locals[:content] = content
       else
-        content
+        layout = {:template => layout, :locals => {:content => content}}
       end
+      
+      render(layout)
     end
-    
-    def render_erb(template, options={})
+
+    # Renders the specified template as ERB using the options.  Options:
+    #
+    #   locals:: a hash of local variables used in the template
+    #
+    # The filename used to identify errors in an erb template to a specific
+    # file and is completely options (but handy).
+    def render_erb(template, options={}, filename=nil)
       # assign locals to the render binding
       # this almost surely may be optimized...
       locals = options[:locals]
-      binding = empty_binding
-      
+      binding = render_erb_binding
+
       locals.each_pair do |key, value|
         @assignment_value = value
         eval("#{key} = remove_instance_variable(:@assignment_value)", binding)
       end if locals
+
+      erb = ERB.new(template, nil, "<>")
+      erb.filename = filename
+      erb.result(binding)
+    end
+    
+    def module_render(path, obj, options={})
+      obj = obj.class unless obj.kind_of?(Module)
+      options[:file] = module_path(path, obj) || module_path(path)
+      
+      locals = options[:locals] ||= {}
+      locals[:obj] ||= obj
       
-      ERB.new(template, nil, "<>").result(binding)
+      render options
     end
     
     # Redirects to the specified uri.
@@ -245,38 +367,15 @@ module Tap
       response.status = status
       response.headers.merge!(headers)
       response.body = body
-      
-      response['Location'] = uri
+
+      response['Location'] = [uri]
       response.finish
     end
     
-    # Returns a session hash.
-    def session
-      request.env['rack.session'] ||= {}
-    end
-    
-    # Returns the app for the current session.
-    def app
-      server.app(session[:id] ||= server.initialize_session)
-    end
-    
-    # Returns the root for the current session.
-    def root
-      server.root(session[:id] ||= server.initialize_session)
-    end
-    
-    # Returns the file-based controller persistence.
-    def persistence
-      @persistence ||= Support::Persistence.new(root)
-    end
-    
-    # Returns a controller uri.
-    def uri(action=nil, params={})
-      server.uri(self.class.name, action, params)
-    end
+    private
     
     # Generates an empty binding to self without any locals assigned.
-    def empty_binding # :nodoc:
+    def render_erb_binding # :nodoc:
       binding
     end
   end