spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/rack/middleware/authenticate.rb

@@ -6,8 +6,8 @@ module Spontaneous::Rack::Middleware
     class Init
       include Spontaneous::Rack::Constants
 
-      def initialize(app)
-        @app = app
+      def initialize(app, site)
+        @app, @site = app, site
       end
 
       def call(env)
@@ -20,7 +20,7 @@ module Spontaneous::Rack::Middleware
 
       def authenticate(env)
         remote_addr = env["REMOTE_ADDR"]
-        if (login = Spontaneous::Site.config.auto_login)
+        if (login = @site.config.auto_login)
           auto_login(login, remote_addr)
         else
           cookie_login(env, remote_addr)

data/lib/spontaneous/rack/middleware/reloader.rb

@@ -10,9 +10,10 @@ module Spontaneous::Rack::Middleware
   class Reloader
     include Spontaneous::Rack::Back::TemplateHelpers
 
-    def initialize(app, *args)
+    def initialize(app, site, *args)
       @app      = app
-      @active   = Spontaneous::Site.config.reload_classes
+      @site     = site
+      @active   = @site.config.reload_classes
       config    = args.first || {}
       @cooldown = config[:cooldown] || 3
       @last     = (Time.now - @cooldown)

data/lib/spontaneous/rack/middleware/scope.rb

@@ -1,33 +1,39 @@
 module Spontaneous::Rack::Middleware
   module Scope
-    class Edit
-
-      def initialize(app)
-        @app = app
+    class Base
+      def initialize(app, site, options = {})
+        raise "Missing site instance" if site.nil?
+        @app, @site, @options = app, site, options
       end
 
       def call(env)
+        env[Spontaneous::Rack::SITE] = @site
+        call!(env)
+      end
+    end
+
+    class Edit < Base
+      def call!(env)
         response = nil
-        Spontaneous::Content.scope(nil, false) do
+        @site.model.scope(nil, false) do
           response = @app.call(env)
         end
         response
       end
     end
 
-    class Preview
+    class Preview < Base
       include Spontaneous::Rack::Constants
 
-      def initialize(app)
-        @app = app
-        @renderer = Spontaneous::Output.preview_renderer
-        Spontaneous::Output.renderer = @renderer
+      def initialize(app, site, options = {})
+        super
+        @renderer = Spontaneous::Output.preview_renderer(@site)
       end
 
-      def call(env)
+      def call!(env)
         env[RENDERER] = @renderer
         response = nil
-        Spontaneous::Content.scope(nil, true) do
+        @site.model.scope(nil, true) do
           response = @app.call(env)
         end
         response
@@ -38,19 +44,19 @@ module Spontaneous::Rack::Middleware
       "X-Powered-By" => "Spontaneous CMS v#{Spontaneous::VERSION}"
     }
 
-    class Front
+    class Front < Base
       include Spontaneous::Rack::Constants
 
-      def initialize(app)
-        @app = app
-        @renderer = Spontaneous::Output.published_renderer
+      def initialize(app, site, options = {})
+        super
+        @renderer = Spontaneous::Output.published_renderer(@site)
       end
 
-      def call(env)
+      def call!(env)
         status = headers = body = nil
         env[RENDERER] = @renderer
-        env[REVISION] = Spontaneous::Site.published_revision
-        Spontaneous::Content.with_published do
+        env[REVISION] = @site.published_revision
+        @site.model.with_published(@site) do
           status, headers, body = @app.call(env)
         end
         [status, headers.merge(POWERED_BY), body]

data/lib/spontaneous/rack/page_controller.rb

@@ -4,28 +4,179 @@ require 'sinatra/base'
 
 module Spontaneous::Rack
   class PageController < Sinatra::Base
-    include Spontaneous::Rack::Public
-    attr_reader :content, :page, :output
+    class << self
+      # We wrap Sinatra's route methods in order to do two things:
+      #   1. To provide a path of '/' when none is given and
+      #   2. To register the presence of a handler for each method in order to
+      #      correctly respond to the #dynamic? test
+      def get(*args, &bk)     __dynamic!(:get,     super(*__route_args(args), &bk)) end
+      def put(*args, &bk)     __dynamic!(:put,     super(*__route_args(args), &bk)) end
+      def post(*args, &bk)    __dynamic!(:post,    super(*__route_args(args), &bk)) end
+      def delete(*args, &bk)  __dynamic!(:delete,  super(*__route_args(args), &bk)) end
+      def head(*args, &bk)    __dynamic!(:head,    super(*__route_args(args), &bk)) end
+      def options(*args, &bk) __dynamic!(:options, super(*__route_args(args), &bk)) end
+      def patch(*args, &bk)   __dynamic!(:patch,   super(*__route_args(args), &bk)) end
+      def link(*args, &bk)    __dynamic!(:link,    super(*__route_args(args), &bk)) end
+      def unlink(*args, &bk)  __dynamic!(:unlink,  super(*__route_args(args), &bk)) end
 
-    def initialize(content, output)
-      @content, @output = content, (output || :html).to_sym
+      def dynamic?(method = :get)
+        __dynamic[method]
+      end
+
+
+      private
+
+      def __route_args(args)
+        opts = args.extract_options!
+        path = String === args.first ? args.first : '/'
+        [path, opts]
+      end
+
+      def __dynamic!(method, action)
+        __dynamic[method] = true
+      end
+
+      def __dynamic
+        @__dynamic ||= {}
+      end
+    end
+
+    attr_reader :content, :site
+
+    def initialize(site, content, output)
+      @site, @content, @output, @locals = site, content, output, {}
       @page = content.page
       super(nil)
     end
 
+    # render [instance (Content), output (Symbol), status (Fixnum), locals (Hash)]
+    # render [uid (Symbol), status (Fixnum), locals (Hash)] => [instance, output, status, locals]
+    # render [uid (Symbol)]       => [uid, output, 200, {}]
+    # render [instance (Content)] => [instance, output, 200, {}]
+    # render [locals (Hash)] => [page, output, 200, locals]
+    # render [status (Fixnum)] => [page, output, status, {}]
+    # render(:home, :xml, 200, {logged_in: true}) # => :home => uid, :xml => output
+    # render(:home, 200, {logged_in: true}) # => :home => uid
+    # render(:home, {logged_in: true}) # => :home => uid
+    # render(:xml, 200, {logged_in: true}) # NOT ALLOWED: if you want to specify the output then you must also specify the page
+    # render(403, {logged_in: false})
+    #
+    # Every controller *must* include a call to render
     def render(*args)
-      params = args.extract_options!
-      output = @output
-      page   = @page
-      args.each do |arg|
-        case arg
-        when Symbol
-          output = arg
-        when Spontaneous::Content
+      @locals = args.extract_options!
+      show(*args)
+      render_body
+    end
+
+    # Show provides a way to configure future calls to render without the overhead of
+    # calling #render itself. Good if you want to set up a default state & then override
+    # it later.
+    # Only #render accepts a locals hash that is passed into the render call
+    def show(*args)
+      page, output, status = self.page, self.output, self.status
+      case args.length
+      when 3
+        page, output, status = args
+      when 2
+        page, last = args
+        case last
+        when Fixnum
+          status = last
+        else
+          output = last
+        end
+      when 1
+        case (arg = args.first)
+        when Fixnum
+          status = arg
+        else
           page = arg
         end
       end
-      _render_page_with_output(page, output, params)
+      page(page)
+      status(status)
+      output(output)
+    end
+
+
+    REDIRECTS = {
+      :permanent => 301,
+      :temporary => 302
+    }
+
+    def redirect(location, redirect_code=:temporary)
+      if String === location
+        destination = @site[location]
+        location = destination.path if destination and destination.respond_to?(:path)
+      else
+        location = location.path if location.respond_to?(:path)
+      end
+      redirect_code = REDIRECTS[redirect_code] if Symbol === redirect_code
+      redirect_code ||= REDIRECTS[:temporary]
+      # let Sinatra's helper method set up the proper Location headers for us
+      catch(:halt) { super(location) }
+      status(redirect_code)
+      # then re-throw the :halt
+      halt
+    end
+
+    def output(*args)
+      return @output if args.empty?
+      @output = args.first
+    end
+
+    def not_found
+      super(not_found_body)
+    end
+
+    def page(page = nil)
+      return @page if page.nil?
+      @page = fetch_page(page)
+    end
+
+    private
+
+    def renderer
+      env[Spontaneous::Rack::RENDERER]
+    end
+
+    def fetch_page(page)
+      return @site[page] if (String === page) || (Symbol === page)
+      page
+    end
+
+    def render_body
+      body(render_page)
+    end
+
+    def render_page
+      not_found if     page.nil?
+      not_found unless page.provides_output?(self.output)
+      output = page.output(self.output)
+      render_output(output)
+    end
+
+    def render_output(output)
+      if output.public?
+        content_type(output.mime_type)
+        do_render(output, @locals)
+      else
+        not_found
+      end
+    end
+
+    def do_render(output, locals)
+      locals = locals.merge({
+        params: params, # use sinatras indifferent params
+        request: request,
+        session: request.session,
+        env: request.env
+      })
+      output.render_using(renderer, locals)
+    end
+
+    def not_found_body
+      "not found"
     end
   end
 end

data/lib/spontaneous/rack/public.rb

@@ -5,7 +5,7 @@ module Spontaneous
   module Rack
     module Public
       include Constants
-      include Sinatra::Helpers unless method_defined?(:redirect)
+      # include Sinatra::Helpers unless method_defined?(:redirect)
 
       attr_reader :env, :response, :request
       attr_accessor :page
@@ -17,10 +17,10 @@ module Spontaneous
         response = catch(:halt) do
           if @page
             case @request.request_method
-            when METHOD_GET
+            when METHOD_GET, METHOD_HEAD
               render_get
             else
-              render_post
+              render_other
             end
           else
             not_found!
@@ -41,17 +41,10 @@ module Spontaneous
         [status, header, body]
       end
 
-      def halt(*response)
-        response = response.first if response.length == 1
-        throw :halt, response
-      end
-
-
-
       # stolen from Sinatra
       def parse_response(response)
         case
-        when response.is_a?(Spontaneous::Content)
+        when response.is_a?(site.model)
           @page = response
         when response.respond_to?(:to_str)
           @response.body = [response]
@@ -81,45 +74,13 @@ module Spontaneous
       DOT = '.'.freeze
       ACTION = "/#{S::Model::Page::Controllers::ACTION_SEPARATOR}".freeze
 
-      def show(page, status=200)
-        page = Spontaneous::Site[page] if String === page
-        @page = page
-        status(status)
-      end
-
-      def render(page, template_params = {})
-        @template_params = template_params
-        show(page)
-      end
-
-      REDIRECTS = {
-        :permanent => 301,
-        :temporary => 302
-      }
-
-      def redirect(location, redirect_code=:temporary)
-        if String === location
-          destination = Spontaneous::Site[location]
-          location = destination.path if destination and destination.respond_to?(:path)
-        else
-          location = location.path if location.respond_to?(:path)
-        end
-        redirect_code = REDIRECTS[redirect_code] if Symbol === redirect_code
-        redirect_code ||= REDIRECTS[:temporary]
-        # let Sinatra's helper method set up the proper Location headers for us
-        catch(:halt) { super(location) }
-        status(redirect_code)
-        # then re-throw the :halt
-        halt
-      end
-
       def content_type(type, params={})
-        default = params.delete :default
+        default   = params.delete :default
         mime_type = mime_type(type) || default
         fail "Unknown media type: %p" % type if mime_type.nil?
         mime_type = mime_type.dup
         unless params.include? :charset
-          params[:charset] = params.delete('charset') || ::Spontaneous.config.default_charset || 'utf-8'
+          params[:charset] = params.delete('charset') || site.config.default_charset || 'utf-8'
         end
         mime_type << ";#{params.map { |kv| kv.join('=') }.join(', ')}" unless params.empty?
         response['Content-Type'] = mime_type
@@ -131,7 +92,7 @@ module Spontaneous
       end
 
       def find_page_by_path(path)
-        Spontaneous::Site.by_path(path)
+        site.by_path(path)
       end
 
       def output(name)
@@ -143,34 +104,34 @@ module Spontaneous
       end
 
       def render_get
-        if @action
-          call_action!
+        return call_action! if @action
+        if page.dynamic?(request.request_method)
+          invoke_action { page.process_root_action(site, env.dup, @output) }
         else
-          block = page.request_block(request)
-          parse_response(instance_eval(&block)) if (block)
           render_page_with_output
         end
       end
 
-      # non-action urls shouldn't respond to post requests
-      def render_post
-        block = page.request_block(request)
-        return not_found! unless (block or @action)
+      # Only pages that provide a controller for the current URL should respond
+      # to anything other than GET or HEAD
+      def render_other
+        return not_found! unless (page.dynamic?(request.request_method) or @action)
 
-        if @action
-          call_action!
-        else
-          parse_response(instance_eval(&block)) if (block)
-          render_page_with_output
-        end
+        return call_action! if @action
+
+        invoke_action { page.process_root_action(site, env.dup, @output) }
       end
 
       def call_action!
-        status, headers, result = @page.process_action(action, request.env, @output)
+        invoke_action { @page.process_action(site, action, env.dup, @output) }
+      end
+
+      def invoke_action
+        status, headers, result = yield
         if status == 404
           not_found!
         else
-          if result.is_a?(Spontaneous::Content)
+          if result.is_a?(site.model)
             @page = result
             render_page_with_output
           else