spontaneous 0.1.0.alpha1

data/lib/spontaneous/rack/front.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require 'sinatra/base'
+
+module Spontaneous
+  module Rack
+    module Front
+      def self.application
+        app = ::Rack::Builder.new do
+          # use ::Rack::CommonLogger, STDERR  #unless server.name =~ /CGI/
+          # use ::Rack::ShowExceptions
+
+          use Spontaneous::Rack::Static, :root => Spontaneous.root / "public",
+            :urls => %w[/],
+            :try => ['.html', 'index.html', '/index.html']
+
+          map "/media" do
+            run Spontaneous::Rack::Media.new
+          end
+
+          map "/" do
+            use AroundFront
+            use Reloader if Site.config.reload_classes
+            run Server.new
+          end
+        end
+      end
+      class Server# < Spontaneous::Rack::Public
+        include Spontaneous::Rack::Public
+
+        def call(env)
+          @response = ::Rack::Response.new
+          @request = ::Rack::Request.new(env)
+          render_path(@request.path_info)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/spontaneous/rack/http.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Rack
+    module HTTP
+      METHOD_GET = "GET".freeze
+      METHOD_POST = "POST".freeze
+      METHOD_HEAD = "HEAD".freeze
+      HTTP_CONTENT_LENGTH = "Content-Length".freeze
+      HTTP_EXPIRES = "Expires".freeze
+      HTTP_CACHE_CONTROL = "Cache-Control".freeze
+      HTTP_LAST_MODIFIED = "Last-Modified".freeze
+      HTTP_NO_CACHE = "max-age=0, must-revalidate, no-cache, no-store".freeze
+    end
+  end
+end
+

data/lib/spontaneous/rack/media.rb

@@ -0,0 +1,29 @@
+
+module Spontaneous
+  module Rack
+    class Media < ::Rack::File
+      include HTTP
+
+      TEN_YEARS = 10*365*24*3600
+      MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
+
+      def initialize
+        super(Spontaneous.media_dir, 'public')
+      end
+
+      def call(env)
+        status, headers, body = super
+        [status, caching_headers(headers), body]
+      end
+
+      # media is never over-written so we can make sure clients
+      # never make the same request twice
+      def caching_headers(headers)
+        headers.merge({
+          HTTP_CACHE_CONTROL => MAX_AGE,
+          HTTP_EXPIRES => (Time.now + TEN_YEARS).httpdate
+        })
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/public.rb

@@ -0,0 +1,232 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Rack
+    module Public
+      include HTTP
+      include Sinatra::Helpers unless method_defined?(:redirect)
+
+
+      attr_reader :response, :request
+      attr_accessor :page
+
+      def render_path(path)
+        find_page!(path)
+
+        response = catch(:halt) do
+          if @page
+            case @request.request_method
+            when METHOD_GET
+              render_get
+            else
+              render_post
+            end
+          else
+            not_found!
+          end
+        end
+
+        parse_response(response)
+        status, header, body = @response.finish
+
+        # Never produce a body on HEAD requests. Do retain the Content-Length
+        # unless it's "0", in which case we assume it was calculated erroneously
+        # for a manual HEAD response and remove it entirely.
+        if request.request_method == METHOD_HEAD
+          body = []
+          header.delete(HTTP_CONTENT_LENGTH) if header[HTTP_CONTENT_LENGTH] == '0'
+        end
+
+        [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.respond_to?(:spontaneous_content?)
+          @page = response
+        when response.respond_to?(:to_str)
+          @response.body = [response]
+        when response.respond_to?(:to_ary)
+          response = response.to_ary
+          if Fixnum === response.first
+            if response.length == 3
+              @response.status, headers, body = response
+              @response.body = body if body
+              headers.each { |k, v| @response.headers[k] = v } if headers
+            elsif response.length == 2
+              @response.status = response.first
+              @response.body   = response.last
+            else
+              raise TypeError, "#{response.inspect} not supported"
+            end
+          else
+            @response.body = response
+          end
+        when response.respond_to?(:each)
+          @response.body = response
+        when (100..599) === response
+          @response.status = response
+        end
+      end
+
+      DOT = '.'.freeze
+      ACTION = "/#{S::Plugins::Controllers::ACTION_SEPARATOR}".freeze
+
+      def show(page, status=200)
+        page = Spontaneous::Site[page] if String === page
+        @page = page
+        status(status)
+      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 content_type(type, params={})
+        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'
+        end
+        mime_type << ";#{params.map { |kv| kv.join('=') }.join(', ')}" unless params.empty?
+        response['Content-Type'] = mime_type
+      end
+
+      def find_page!(path)
+        @path, @format, @action = parse_path(path)
+        @page = Site[@path]
+      end
+
+      def format
+        @format
+      end
+
+      def action
+        @action
+      end
+
+      def render_get
+        # return not_found! unless @page
+
+        @format = (@format || @page.default_format).to_sym if @page
+
+        if @action
+          call_action!
+        else
+          block = page.request_block(request)
+          parse_response(instance_eval(&block)) if (block)
+
+          @format = (@format || @page.default_format).to_sym if @page
+          render_page_with_format(@page, @format)
+        end
+      end
+
+      # non-action urls shouldn't respond to post requests
+      def render_post
+        # return not_found! unless @page
+
+        block = page.request_block(request)
+        return not_found! unless (block or @action)
+
+        if @action
+          call_action!
+        else
+          parse_response(instance_eval(&block)) if (block)
+
+          @format = (@format || @page.default_format).to_sym if @page
+          render_page_with_format(@page, @format)
+        end
+      end
+
+      def call_action!
+        # get
+        status, headers, result = @page.process_action(action, request.env, format)
+        # our 404 page should come from the CMS
+        if status == 404
+          not_found!
+        else
+          if result.respond_to?(:spontaneous_content?)
+            render_page_with_format(result, format)
+          else
+            [status, headers, result]
+          end
+        end
+      end
+
+      def parse_path(path)
+        if path =~ %r(#{ACTION})
+          path, action = path.split(ACTION)
+          action, format = action.split(DOT)
+        else
+          path, format = path.split(DOT)
+        end
+        # format = (format || :html).to_sym
+        [path, format, action]
+      end
+
+      def render_page_with_format(page, format)
+        if page && page.provides_format?(format)
+          content_type(page.mime_type(format))
+          render_page(page, format)
+        else
+          # perhaps we should return the html version if the page exists but
+          # doesn't respond to the requested format?
+          # or even redirect to the html?
+          not_found!
+        end
+      end
+
+      def render_page(page, format = :html, local_params = {})
+        response.body = page.render(format, local_params.merge({
+          :params => request.params,
+          :request => request,
+          :session => request.session
+        }))
+      end
+
+      # def redirect?(page)
+      #   redirection, redirect_code = page.request_redirect(request.params, request, request.session)
+      #   if redirection
+      #     redirection = redirection.path if redirection.respond_to?(:path)
+      #     redirect_code = REDIRECTS[redirect_code] if Symbol === redirect_code
+      #     redirect_code ||= REDIRECTS[:temporary]
+      #     [redirection.to_s, redirect_code]
+      #   else
+      #     nil
+      #   end
+      # end
+
+      def not_found!
+        404
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/reloader.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require 'stringio'
+require 'erubis'
+require 'tilt'
+
+module Spontaneous
+  module Rack
+    class Reloader
+      def initialize(app)
+        @app = app
+        @cooldown = 3
+        @last = (Time.now - @cooldown)
+      end
+
+
+      def call(env)
+        if @cooldown and Time.now > @last + @cooldown
+          if Thread.list.size > 1
+            Thread.exclusive{ reload! }
+          else
+            reload!
+          end
+
+          @last = Time.now
+        end
+
+        @app.call(env)
+      rescue Spontaneous::SchemaModificationError => error
+        template = Tilt::ErubisTemplate.new(File.expand_path('../../../../application/views/schema_modification_error.html.erb', __FILE__))
+        html = template.render(error.modification, :env => env)
+        [412, {'Content-type' => ::Rack::Mime.mime_type('.html')}, StringIO.new(html)].tap do |response|
+        end
+      end
+
+      def reload!
+        Spontaneous.reload!
+      end
+    end # Reloader
+  end # Rack
+end # Spontaneous
+

data/lib/spontaneous/rack/static.rb

@@ -0,0 +1,25 @@
+
+module Spontaneous
+  module Rack
+    class Static
+      def initialize(app, options)
+        @app = app
+        @try = ['', *options.delete(:try)].compact
+        @static = ::Rack::Static.new(
+          lambda { |env| [404, {}, []] },
+          options)
+      end
+
+      def call(env)
+        orig_path = env['PATH_INFO']
+        found = nil
+        @try.each do |path|
+          resp = @static.call(env.merge!({'PATH_INFO' => orig_path + path}))
+          break if 404 != resp[0] && found = resp
+        end
+        found or @app.call(env.merge!('PATH_INFO' => orig_path))
+      end
+
+    end
+  end
+end

data/lib/spontaneous/rack.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require "rack"
+# require "sinatra"
+require 'sinatra/base'
+
+module Spontaneous
+  module Rack
+    class << self
+      def application
+        case Spontaneous.mode
+        when :back
+          Back.application
+        when :front
+          Front.application
+        end
+      end
+
+      def port
+        Site.config.port
+      end
+    end
+
+    class ServerBase < ::Sinatra::Base
+      set :environment, Proc.new { Spontaneous.environment }
+
+      # serve static files from the app's public dir
+
+      ## removed these as sinatra now sets utf-8 by default
+      # mime_type :js,  'text/javascript; charset=utf-8'
+      # mime_type :css, 'text/css; charset=utf-8'
+
+      # before do
+      #   ## globally setting this screws up auto content type setting by send_file
+      #   # content_type 'text/html', :charset => 'utf-8'
+      #   if Spontaneous.development?
+      #     # Templates.clear_cache!
+      #   end
+      # end
+    end
+
+    autoload :HTTP, 'spontaneous/rack/http'
+    autoload :Assets, 'spontaneous/rack/assets'
+    autoload :Back, 'spontaneous/rack/back'
+    autoload :Front, 'spontaneous/rack/front'
+    autoload :Public, 'spontaneous/rack/public'
+    autoload :Media, 'spontaneous/rack/media'
+    autoload :Static, 'spontaneous/rack/static'
+    autoload :AroundBack, 'spontaneous/rack/around_back'
+    autoload :AroundFront, 'spontaneous/rack/around_front'
+    autoload :AroundPreview, 'spontaneous/rack/around_preview'
+    autoload :Reloader, 'spontaneous/rack/reloader'
+  end
+end
+

data/lib/spontaneous/render/context.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Render
+  module Context
+
+    attr_reader :format, :target
+
+    def initialize(target, format, params={})
+      @target, @format, @params = target, format, params
+      _update(params) if params.is_a?(Hash)
+    end
+
+    def page
+      target.page
+    end
+
+    def template
+      target.template(format)
+    end
+
+    def each
+      content.each { |c| yield(c) } if block_given?
+    end
+
+    def each_with_index
+      content.each_with_index { |c, i| yield(c, i) } if block_given?
+    end
+
+    def map
+      content.map { |c| yield(c) } if block_given?
+    end
+
+    def content
+      target.iterable
+    end
+
+    def pieces
+      content
+    end
+
+    def first
+      content.first
+    end
+
+    def last
+      content.last
+    end
+
+    def first?
+      target.container.pieces.first == self
+    end
+
+    def last?
+      target.container.pieces.last == self
+    end
+
+    def render_content
+      target.map do |c|
+        c.render(format)
+      end.join("\n")
+    end
+
+    def render(format, *args)
+      target.render(format, *args)
+    end
+
+    def respond_to?(method)
+      super || target.respond_to?(method)
+    end
+
+    protected
+
+    def method_missing(method, *args)
+      if block_given?
+        target.__send__(method, *args, &Proc.new)
+      else
+        target.__send__(method, *args)
+      end
+    rescue => e
+      # TODO: sensible, configurable fallback for when template calls non-existant method
+      # - need line number and file that generated error
+      # - logging.warn when happens
+      # - an inline comment when in dev mode?
+      # - some placeholder text, perhaps the name of the missing method and line no.
+      logger.error(e)
+      # logger.error(target)
+      # logger.error(e.backtrace.join("\\n"))
+      nil
+    end
+
+    # make each key of the params hash into a method call for speed
+    def _update(params)
+      params.each do |key, val|
+        singleton_class.__send__(:define_method, key) { val }
+      end
+    end
+  end
+end
+

data/lib/spontaneous/render/development_renderer.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Render
+    class DevelopmentRenderer < Renderer
+      def render_content(content, format=:html, params = {})
+        template = publishing_renderer.render_file(content.template(format), content, format, params)
+        result = request_renderer.render_string(template, content, format, params)
+      end
+    end # DevelopmentRenderer
+  end # Render
+end # Spontaneous
+

data/lib/spontaneous/render/engine.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Spontaneous::Render
+  class Engine
+    attr_reader :template_root
+    attr_accessor :template_class
+    attr_accessor :context_class
+
+    def initialize(template_root)
+      @template_root = File.expand_path(template_root)
+    end
+
+    def render_content(content, format=:html)
+      context = context_class.new(content, format)
+      self.render(context)
+    end
+  end
+end
+

data/lib/spontaneous/render/format/html.rb

@@ -0,0 +1,5 @@
+module Spontaneous::Render::Format
+  class Html < Spontaneous::Render::FormatBase
+  end
+end
+

data/lib/spontaneous/render/format.rb

@@ -0,0 +1,70 @@
+
+module Spontaneous::Render
+  module Format; end
+
+  class FormatBase
+    def self.format
+      @format ||= self.name.demodulize.downcase.to_sym
+    end
+
+
+    attr_reader :progress
+
+    def initialize(revision, pages, progress=nil)
+      @revision, @pages, @progress = revision, pages.find_all { |page| page.formats.include?(format) }, progress
+    end
+
+    def format
+      self.class.format
+    end
+
+    def render
+      before_render
+      delay = Spontaneous::Site.config.publishing_delay
+      @pages.each_with_index do |page, n|
+        render_page(page) if page.formats.include?(format)
+        after_page_rendered(page)
+        # sleep(delay) if delay
+        # sleep(3)
+      end
+      after_render
+    end
+
+    def after_page_rendered(page)
+      progress.page_rendered(page) if progress
+    end
+
+    def before_render; end
+    def after_render; end
+
+    def render_page(page)
+      output = page.render(format)
+      path = output_path(page, output)
+      File.open(path, 'w') do |f|
+        f.write(output)
+      end
+    end
+
+    def output_path(page, output)
+      ext = nil
+      ext = renderer.extension if Spontaneous.template_engine.is_dynamic?(output)
+      path = Spontaneous::Render.output_path(@revision, page, format, ext)
+
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      path
+    end
+
+    def revision_root
+      Spontaneous.revision_dir(@revision)
+    end
+
+    def renderer
+      Spontaneous::Render.renderer
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'format', '*.rb')].each do |format|
+  require format
+end

data/lib/spontaneous/render/preview_renderer.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Render
+    class PreviewRenderer < Renderer
+      def render_content(content, format=:html, params = {})
+        # render content using first_pass_renderer
+        # then render this using second_pass_renderer
+        template = preview_renderer.render_file(content.template(format), content, format, params)
+        result = request_renderer.render_string(template, content, format, params)
+
+        result
+      end
+    end # PreviewRenderer
+  end # Render
+end # Spontaneous
+