tap-server 0.3.0 → 0.4.0

data/lib/tap/server/data.rb

@@ -0,0 +1,178 @@
+module Tap
+  class Server
+    
+    # A very simple wrapper for root providing a CRUD interface for reading and
+    # writing files.  Data ids may be integers (if you want to pretend Data is
+    # a database), or they can be relative paths.
+    class Data < Tap::Root
+      
+      attr_reader :cache
+      
+      def initialize(config_or_dir=Dir.pwd)
+        @cache = Hash.new([])
+        
+        if config_or_dir.kind_of?(Tap::Root)
+          config_or_dir = config_or_dir.config.to_hash
+        end
+        
+        super(config_or_dir)
+      end
+      
+      # A restricted version of the original.  Path raises an error if the
+      # final path is not relative to als.
+      def entry_path(als, id)
+        id = id.to_s
+        if id.empty?
+          raise "no id specified" 
+        end
+        
+        path = self.path(als, id)
+        unless relative?(als, path)
+          raise "not a subpath: #{id.inspect} (#{als.inspect})"
+        end
+        
+        path
+      end
+      
+      # Returns a list of entry paths.
+      def entries(als)
+        glob(als).select do |path|
+          File.file?(path)
+        end
+      end
+      
+      # Returns a list of existing ids.
+      def index(als)
+        entries(als).collect do |path|
+          relative_path(als, path)
+        end
+      end
+      
+      # Returns an available integer id, usually the number of entries in self,
+      # but a random integer is generated if that number is taken.
+      def next_id(als)
+        # try the next in the sequence
+        id = entries(als).length
+        
+        # if that already exists, go for a random id
+        while find(als, id)
+          id = rand(id * 10000)
+        end
+        
+        id
+      end
+      
+      # Returns the path for the specified entry, if it exists.  Returns nil
+      # if no such entry can be found.
+      def find(als, id)
+        return nil unless id
+        
+        path = entry_path(als, id)
+        File.file?(path) ? path : nil
+      end
+      
+      # Creates an entry (ie a file) for the specified id.  Yields the open
+      # file to the block if given, otherwise the file will be created
+      # without content.  Returns the path to the file.
+      #
+      # Raises an error if the file already exists.
+      def create(als, id)
+        path = non_existant_path(als, id)
+        create!(path) {|io| yield(io) if block_given? }
+      end
+      
+      # Reads and returns the data for the specified entry, or nil if
+      # the entry doesn't exist.
+      def read(als, id)
+        path = find(als, id)
+        path ? File.read(path) : nil
+      end
+      
+      # Overwrites the data for the specified entry.  A block must be given to
+      # provide the new content; an error is raised if the entry does not
+      # already exist.
+      def update(als, id)
+        path = existing_path(als, id)
+        create!(path) {|io| yield(io) }
+      end
+      
+      # Removes the specified entry (ie file), if it exists.  Returns true if
+      # the file was removed and false otherwise.
+      def destroy(als, id)
+        if path = find(als, id)
+          FileUtils.rm(path)
+          cache[als].delete(id)
+          true
+        else
+          false
+        end
+      end
+      
+      def create_or_update(als, id)
+        path = entry_path(als, id)
+        create!(path) {|io| yield(io) }
+      end
+      
+      def import(als, upload, id=nil)
+        id = upload[:filename] unless id && !id.empty?
+        path = non_existant_path(als, id)
+        
+        prepare(path)
+        FileUtils.mv(upload[:tempfile].path, path)
+        path
+      end
+      
+      def move(als, id, new_id)
+        path = existing_path(als, id)
+        new_path = non_existant_path(als, new_id)
+        
+        prepare(new_path)
+        FileUtils.mv(path, new_path)
+        
+        if cache[als].include?(id)
+          cache[als].delete(id)
+          cache[als] << new_id
+        end
+        
+        new_id
+      end
+      
+      def copy(als, id, new_id)
+        path = existing_path(als, id)
+        new_path = non_existant_path(als, new_id)
+        
+        prepare(new_path)
+        FileUtils.copy(path, new_path)
+        new_id
+      end
+      
+      protected
+      
+      # helper to optimize the creation of entries when path is already
+      # resolved (using the instance prepare requires a second path
+      # resolution)
+      def create!(path) # :nodoc:
+        Utils.prepare(path) {|io| yield(io) }
+      end
+      
+      # like find but raises an error if the path doesn't exist
+      def existing_path(als, id)
+        path = entry_path(als, id)
+        unless File.exists?(path)
+          raise "does not exist: #{id.inspect} (#{als.inspect})"
+        end
+        path
+      end
+      
+      # like find but raises an error if the path exists
+      def non_existant_path(als, id) # :nodoc:
+        path = entry_path(als, id)
+        if File.exists?(path)
+          raise "already exists: #{id.inspect} (#{als.inspect})"
+        end
+        path
+      end
+
+    end
+  end
+end

data/lib/tap/server/runner.rb

@@ -0,0 +1,71 @@
+require 'rack'
+
+module Tap
+  class Server
+    module Runner
+      include Rack::Utils
+      include Configurable
+    
+      config :servers, %w[thin mongrel webrick], {    # the preferred server handlers
+        :long => :server
+      }, &c.list 
+    
+      config :host, 'localhost', &c.string            # the server host
+      config :port, 8080, &c.integer_or_nil           # the server port
+    
+      attr_reader :handler
+    
+      def initialize(config={})
+        @handler = nil
+        initialize_config(config)
+      end
+    
+      def running?
+        @handler != nil
+      end
+    
+      # Runs self as configured, on the specified server, host, and port.  Use an
+      # INT signal to interrupt.
+      def run!(rack_app, handler=rack_handler)
+        return self if running?
+      
+        handler.run(rack_app, :Host => host, :Port => port) do |handler_instance|
+          @handler = handler_instance
+          trap(:INT) { stop! }
+          yield if block_given?
+        end
+      
+        self
+      end
+
+      # Stops the server if running (ie a handler is set).
+      def stop!
+        if running?
+          # 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
+
+      # 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
+        end
+        raise "Server handler (#{servers.join(',')}) not found."
+      end
+    end
+  end
+end

data/lib/tap/server/server_error.rb

@@ -0,0 +1,35 @@
+module Tap
+  class Server
+    # A special type of error used for specifiying controller errors.
+    class ServerError < RuntimeError
+      class << self
+      
+        # A helper to format a non-ServerError into a ServerError response.
+        def response(err)
+          new("500 #{err.class}: #{err.message}\n#{err.backtrace.join("\n")}").response
+        end
+      end
+    
+      # The error status
+      attr_reader :status
+    
+      # Headers for the error response
+      attr_reader :headers
+    
+      # The error response body
+      attr_reader :body
+  
+      def initialize(body="500 Server Error", status=500, headers={'Content-Type' => 'text/plain'})
+        @body = body
+        @status = status
+        @headers = headers
+        super(body)
+      end
+    
+      # Formats self as a rack response array (ie [status, headers, body]).
+      def response
+        [status, headers, [body]]
+      end
+    end
+  end
+end

data/lib/tap/server.rb

@@ -1,252 +1,76 @@
-require 'rack'
-require 'rack/mock'
-
 require 'tap'
-require 'tap/server_error'
+require 'tap/server/data'
+require 'tap/server/runner'
+require 'tap/server/server_error'
 
 module Tap
-  Env.manifest(:controllers) do |env|
-    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.
-  #
-  # == Routes
-  #
-  # Routing is fixed and very simple:
-  #
-  #   /:controller/path/to/resource
-  #
-  # Server dispatches the request to the controller keyed by :controller after 
-  # shifting the key from PATH_INFO to SCRIPT_NAME.
-  #
-  #   server = Server.new
-  #   server.controllers['sample'] = lambda do |env|
-  #     [200, {}, ["Sample got #{env['SCRIPT_NAME']} : #{env['PATH_INFO']}"]]
-  #   end
-  #
-  #   req = Rack::MockRequest.new(server)
-  #   req.get('/sample/path/to/resource').body      # => "Sample got /sample : /path/to/resource"
-  #
-  # Server automatically maps unknown keys to controllers discovered via the
-  # env.controllers manifest.  The only requirement is that the controller
-  # constant is a Rack application.  For instance:
-  #
-  #   # [lib/example.rb] => %q{
-  #   # ::controller
-  #   # class Example
-  #   #   def self.call(env)
-  #   #     [200, {}, ["Example got #{env['SCRIPT_NAME']} : #{env['PATH_INFO']}"]]
-  #   #   end
-  #   # end 
-  #   # }
-  #
-  #   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      # => "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.
-  #
-  #   server.default_controller_key = 'app'
-  #   server.controllers['app'] = lambda do |env|
-  #     [200, {}, ["App got #{env['SCRIPT_NAME']} : #{env['PATH_INFO']}"]]
-  #   end
-  #
-  #   req.get('/unknown/path/to/resource').body     # => "App got  : /unknown/path/to/resource"
-  #
-  # In development mode, the controller constant is removed and the constant
-  # require path is reloaded each time it gets called.  This system allows many
-  # web frameworks to be hooked into a Tap server.
-  #
-  # :::+
+  # ::configurable
   class Server
-    class << self
-      
-      # Instantiates a Server in the specified directory, configured as
-      # specified in root/server.yml.  If shutdown_key is specified, a
-      # random shutdown key will be generated and set on the sever.
-      #
-      def instantiate(root, shutdown_key=false)
-        # setup the server directory
-        root = File.expand_path(root)
-        FileUtils.mkdir_p(root) unless File.exists?(root)
-
-        # initialize the server
-        app = Tap::App.instance
-        env = Tap::Exe.instantiate(root)
-        env.activate
-        config = Configurable::Utils.load_file(env.root['server.yml'])
-        
-        server = new(env, app, config)
-        server.config[:shutdown_key] = rand(1000000) if shutdown_key
-        server
-      end
-      
-      # Runs the server
-      def run(server)
-        cookie_server = Rack::Session::Pool.new(server)
-        server.run!
-      end
-    end
+    include Runner
     
-    include Rack::Utils
-    include Configurable
+    # Server implements a secret for HTTP administration of the server (ex
+    # remote shutdown). Under many circumstances this functionality is
+    # undesirable; specify a nil secret, the default, to prevent remote
+    # administration.
+    config :secret, nil, &c.string_or_nil           # the admin secret
     
-    config :environment, :development                   
-    config :servers, %w[thin mongrel webrick], &c.list  # a list of preferred handlers
-    config :host, 'localhost', &c.string                # the server host
-    config :port, 8080, &c.integer                      # the server port
+    config :development, false, &c.flag
     
-    # A hash of (key, controller) pairs mapping the controller part of a route
-    # to a Rack application.  Typically controllers is used to specify aliases
-    # when the defaults are not preferable.
-    config :controllers, {}
+    config :router, true, &c.switch
     
-    # config :infer_controllers, true, &c.switch
+    nest :env, Tap::Env, :type => :hidden
     
-    # The default controller key used in routes that cannot be directly mapped
-    # to a controller
-    #--
-    # Set to nil to force controller mapping?
-    config :default_controller_key, 'app'
+    nest :app, Tap::App, :type => :hidden
     
-    # Server implements a shutdown key so the server can be shutdown remotely
-    # via an HTTP request to the app/shutdown method.  Remote shutdown is
-    # useful when the user is running a local server (especially from a
-    # background process).  Under many circumstances remote shutdown is
-    # undesirable; specify a nil shutdown key, the default, to turn off
-    # shutdown.
-    config :shutdown_key, nil, &c.integer_or_nil        # specifies a public shutdown key
+    nest :data, Data, :type => :hidden
     
-    attr_reader :env
-    attr_reader :handler
+    attr_accessor :controller
     
-    def initialize(env=Env.new, app=Tap::App.instance, config={})
-      @env = env
-      @app = app
-      @cache = {}
-      @handler = nil
-      initialize_config(config)
-    end
+    attr_accessor :thread
     
-    # Runs self as configured, on the specified server, host, and port.  Use an
-    # INT signal to interrupt.
-    def run!(handler=rack_handler)
-      app.log :run, "#{host}:#{port} (#{handler})"
-      handler.run self, :Host => host, :Port => port do |handler_instance|
-        @handler = handler_instance
-        trap(:INT) { stop! }
-      end
+    def initialize(controller=nil, config={})
+      @controller = controller
+      @thread = nil
+      super(config)
     end
     
-    # Stops the server if running (ie a handler is set).  Returns true if the
-    # server was stopped, and false otherwise.
-    def stop!
-      if handler
-        # Use thins' hard #stop! if available, otherwise just #stop
-        handler.respond_to?(:stop!) ? handler.stop! : handler.stop
-        @handler = nil
-        false
-      else
-        true
-      end
+    # Returns true if input is equal to the secret, if a secret is set. Used
+    # to test if a particular request has rights to a remote administrative
+    # action.
+    def admin?(input)
+      secret != nil && input == secret
     end
     
-    # Currently a stub for initializing a session.  initialize_session returns
-    # an integer session id.
-    def initialize_session
-      id = 0
-      session_app = app(id)
-      session_root = root(id)
-      
-      # setup expiration information...
-      
-      # setup a session log
-      log_path = session_root.prepare(:log, 'session.log')
-      session_app.logger = Logger.new(log_path)
-      session_app.on_complete do |_result|
-        # find the template
-        class_name = _result.key.class.to_s.underscore
-        pattern = "#{class_name}/result\.*"
-        template = nil
-        env.each do |e|
-          templates = e.root.glob(views_dir, pattern)
-          unless templates.empty?
-            template = templates[0]
-            break
-          end
-        end
-        
-        if template
-          extname = File.extname(template)
-          env.root.prepare(:results, id.to_s, "#{class_name}#{extname}") do |file|
-            file << Support::Templater.new(File.read(template)).build(:_result => _result)
-          end
-        end
-      end unless session_app.on_complete_block
-      
-      id
-    end
-    
-    # Returns the session-specific App, or the server app if id is nil.
-    def app(id=nil)
-      @app
-    end
-    
-    # Returns the session-specific Root, or the server env.root if id is nil.
-    def root(id=nil)
-      @env.root
-    end
-    
-    # Returns a uri mapping to the specified controller and action.  Parameters
-    # may be specified; they are built as a query and attached to the uri as
-    # normal.
-    #
-    # Currenlty uri does not map the controller to a minipath, but in the
-    # future it will.
-    def uri(controller=nil, action=nil, params={})
-      query = build_query(params)
-      uri = ["http://#{host}:#{port}", escape(controller), action].compact.join("/")
-      query.empty? ? uri : "#{uri}?#{query}"
-    end
-    
-    # The {Rack}[http://rack.rubyforge.org/doc/] interface method.
-    def call(rack_env)
-      if development?
-        env.reset 
-        @cache.clear
-      end
+    def route(rack_env)
+      return controller unless router
       
       # route to a controller
-      blank, key, path_info = rack_env['PATH_INFO'].split("/", 3)
-      controller = lookup(unescape(key))
+      blank, path, path_info = rack_env['PATH_INFO'].split("/", 3)
+      controller = lookup_controller(unescape(path))
       
       if controller
-        # adjust env if key routes to a controller
-        rack_env['SCRIPT_NAME'] = ["#{rack_env['SCRIPT_NAME'].chomp('/')}/#{key}"]
+        # 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 key
-        controller = lookup(default_controller_key)
-        
-        unless controller
-          raise ServerError.new("404 Error: could not route to controller", 404)
-        end
+        # use default controller
+        controller = self.controller
+        path = nil
       end
       
+      rack_env['tap.controller_path'] = path
+      controller
+    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
@@ -254,66 +78,27 @@ module Tap
       ServerError.response($!)
     end
     
-    # Searches env for the first matching file, directories are not matched.
-    def search(dir, path)
-      env.search(dir, path) {|file| File.file?(file) }
+    def run!
+      super(self)
     end
     
     protected
     
-    # Returns true if environment is :development.
-    def development? # :nodoc:
-      environment == :development
-    end
-    
-    # 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
-      end
-      raise "Server handler (#{servers.join(',')}) not found."
-    end
-    
-    # a helper method for routing a key to a controller
-    def lookup(key) # :nodoc:
-      return @cache[key] if @cache.has_key?(key)
-      minikey = controllers[key] || key
-      
-      # return registered controllers
-      if minikey.respond_to?(:call)
-        @cache[key] = minikey
-        return minikey
-      end
-      
-      # return if no controller can be found
-      unless const = env.controllers.search(minikey)
-        @cache[key] = nil
-        return nil
-      end
-      
-      # load the require_path in dev mode so that
-      # controllers will be reloaded each time
-      if development? && const.require_path
-        parent = if const.nesting.empty?
-          Object
+    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
-          Tap::Support::Constant.constantize(const.nesting) { nil }
+          nil
         end
-        
-        if parent && parent.const_defined?(const.const_name)
-          parent.send(:remove_const, const.const_name)
-        end
-        
-        load const.require_path
+      else
+        env[:controller][key]
       end
-    
-      @cache[key] = const.constantize
     end
   end
 end