spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/rack/cacheable_file.rb

@@ -0,0 +1,27 @@
+
+module Spontaneous::Rack
+  class CacheableFile < ::Rack::File
+    include HTTP
+
+    TEN_YEARS = 10*365*24*3600
+    MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
+
+    def initialize(file_root)
+      super(file_root, 'public')
+    end
+
+    def call(env)
+      status, headers, body = super
+      [status, caching_headers(headers), body]
+    end
+
+    # Send a far future Expires header and make sure that
+    # the cache control is public
+    def caching_headers(headers)
+      headers.merge({
+        HTTP_CACHE_CONTROL => MAX_AGE,
+        HTTP_EXPIRES => (Time.now + TEN_YEARS).httpdate
+      })
+    end
+  end
+end

data/lib/spontaneous/rack/cookie_authentication.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Rack
+    class CookieAuthentication
+      def initialize(app)
+        @app = app
+      end
+
+      def access_key(env)
+        if login = Site.config.auto_login
+          user = Spontaneous::Permissions::User[:login => login]
+          if user.access_keys.empty?
+            user.generate_access_key
+          else
+            user.access_keys.first
+          end
+        else
+          request = ::Rack::Request.new(env)
+          api_key = request.cookies[Spontaneous::Rack::AUTH_COOKIE]
+          if api_key && key = Spontaneous::Permissions::AccessKey.authenticate(api_key)
+            key
+          else
+            nil
+          end
+        end
+      end
+
+      def call(env)
+        response = nil
+        key = env[S::Rack::ACTIVE_KEY] = access_key(env)
+        user = env[S::Rack::ACTIVE_USER] = key.user if key
+        response = @app.call(env)
+        response
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/css.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+require 'sass'
+
+module Spontaneous::Rack
+  class CSS
+    def initialize(app, options = {})
+      @options = options
+      @root = options.delete(:root)
+      @app = app
+    end
+
+    def call(env)
+      path = env[S::PATH_INFO]
+      if path =~ /\.css$/ and !File.exists?(File.join(@root, path))
+        template = template_root_path(path) + ".scss"
+        if File.exists?(template)
+          render_sass_template(template)
+        else
+          raise Sinatra::NotFound
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    def render_sass_template(template)
+      load_paths = [Spontaneous.css_dir, File.dirname(template), File.join(File.dirname(template), "sass")]
+      engine = Sass::Engine.for_file(template, {
+        :load_paths => load_paths,
+        :filename => template,
+        :cache => false,
+        :style => :expanded
+      })
+      [200, {'Content-type' => 'text/css'}, [engine.render]]
+    end
+
+    def template_root_path(path)
+      basename = File.basename(path, '.css')
+      File.join(@root, File.dirname(path), basename)
+    end
+  end
+end

data/lib/spontaneous/rack/event_source.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Rack
+    class EventSource < ::Simultaneous::Rack::EventSource
+      # def initialize
+      #   @messenger = ::Simultaneous::Rack::EventSource.new
+      #   @app = @messenger.app
+      # end
+
+      # def call(env)
+      #   user = env[S::Rack::ACTIVE_USER]
+      #   if user.nil?
+      #     unauthorized!
+      #   else
+      #     request = ::Rack::Request.new(env)
+      #     key = request[S::Rack::KEY_PARAM]
+      #     if ::S::Permissions::AccessKey.valid?(key, user)
+      #       @app.call(env)
+      #     else
+      #       unauthorized!
+      #     end
+      #   end
+      # end
+
+      # def unauthorized!
+      #   [401, {}, "Unauthorized"]
+      # end
+    end
+  end
+end

data/lib/spontaneous/rack/front.rb

@@ -10,12 +10,35 @@ module Spontaneous
           # use ::Rack::CommonLogger, STDERR  #unless server.name =~ /CGI/
           # use ::Rack::ShowExceptions
 
-          use Spontaneous::Rack::Static, :root => Spontaneous.root / "public",
+
+          use Spontaneous::Rack::Static, :root => Spontaneous.revision_dir / "public",
             :urls => %w[/],
             :try => ['.html', 'index.html', '/index.html']
 
+
+
+          Spontaneous.instance.front_controllers.each do |namespace, controller_class|
+            map namespace do
+              run controller_class
+            end
+          end if Spontaneous.instance
+
+
+          # Make all the files available under plugin_name/public/**
+          # available under the URL /plugin_name/**
+          # Only used in preview mode
+          Spontaneous.instance.plugins.each do |plugin|
+            map "/#{plugin.name}" do
+              run ::Rack::File.new(plugin.paths.expanded(:public))
+            end
+          end if Spontaneous.instance
+
+          map "/rev" do
+            run Spontaneous::Rack::CacheableFile.new(Spontaneous.revision_dir / "rev")
+          end
+
           map "/media" do
-            run Spontaneous::Rack::Media.new
+            run Spontaneous::Rack::CacheableFile.new(Spontaneous.media_dir)
           end
 
           map "/" do
@@ -25,17 +48,16 @@ module Spontaneous
           end
         end
       end
-      class Server# < Spontaneous::Rack::Public
+      class Server < Sinatra::Base
         include Spontaneous::Rack::Public
 
-        def call(env)
-          @response = ::Rack::Response.new
-          @request = ::Rack::Request.new(env)
+        def call!(env)
+          @env = env
+          @response = ::Sinatra::Response.new
+          @request = ::Sinatra::Request.new(env)
           render_path(@request.path_info)
         end
       end
     end
   end
 end
-
-

data/lib/spontaneous/rack/helpers.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Rack
+    module Helpers
+
+      def style_url(style)
+        "#{NAMESPACE}/css/#{style}.css"
+      end
+
+      def script_url(script)
+        "#{NAMESPACE}/js/#{script}.js"
+      end
+
+      def script_list(scripts)
+        if Spontaneous.development?
+          scripts.map do |script|
+            src = "/js/#{script}.js"
+            path = Spontaneous.application_dir(src)
+            size = File.size(path)
+            ["#{NAMESPACE}#{src}", size]
+            # %(<script src="#{NAMESPACE}/js/#{script}.js" type="text/javascript"></script>)
+          end.to_json
+        else
+          # script bundling + compression
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/rack/media.rb

@@ -1,29 +1,30 @@
+# encoding: UTF-8
 
-module Spontaneous
-  module Rack
-    class Media < ::Rack::File
-      include HTTP
+require 'rack'
 
-      TEN_YEARS = 10*365*24*3600
-      MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
+module Spontaneous::Rack
+  class XXX < ::Rack::File
+    include HTTP
 
-      def initialize
-        super(Spontaneous.media_dir, 'public')
-      end
+    TEN_YEARS = 10*365*24*3600
+    MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
 
-      def call(env)
-        status, headers, body = super
-        [status, caching_headers(headers), body]
-      end
+    def initialize(file_root)
+      super(file_root, '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
+    # 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

data/lib/spontaneous/rack/public.rb

@@ -8,7 +8,8 @@ module Spontaneous
       include Sinatra::Helpers unless method_defined?(:redirect)
 
 
-      attr_reader :response, :request
+
+      attr_reader :env, :response, :request
       attr_accessor :page
 
       def render_path(path)

data/lib/spontaneous/rack/query_authentication.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Rack
+    # Rack middleware that only allows access if the access key passed in the request query
+    # matches that used in the cookie
+    #
+    # Depends on CookieAuthentication being in the chain *before* this app to set up the current user in the env
+    class QueryAuthentication
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        user = env[S::Rack::ACTIVE_USER]
+        if user.nil?
+          unauthorized!
+        else
+          request = ::Rack::Request.new(env)
+          key = request[S::Rack::KEY_PARAM]
+          if ::S::Permissions::AccessKey.valid?(key, user)
+            @app.call(env)
+          else
+            unauthorized!
+          end
+        end
+      end
+
+      def unauthorized!
+        [401, {}, "Unauthorized"]
+      end
+    end
+  end
+end
+

data/lib/spontaneous/rack/reloader.rb

@@ -7,9 +7,12 @@ require 'tilt'
 module Spontaneous
   module Rack
     class Reloader
-      def initialize(app)
+      include Spontaneous::Rack::Helpers
+
+      def initialize(app, *args)
         @app = app
-        @cooldown = 3
+        config = args.first || {}
+        @cooldown = config[:cooldown] || 3
         @last = (Time.now - @cooldown)
       end
 
@@ -28,7 +31,7 @@ module Spontaneous
         @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)
+        html = template.render(self, :modification => error.modification, :env => env)
         [412, {'Content-type' => ::Rack::Mime.mime_type('.html')}, StringIO.new(html)].tap do |response|
         end
       end

data/lib/spontaneous/rack/user_helpers.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Rack
+    module UserHelpers
+
+      def unauthorised!
+        halt 401#, "You do not have the necessary permissions to update the '#{name}' field"
+      end
+
+      def api_key
+        request.cookies[AUTH_COOKIE]
+      end
+
+      def user
+        @user ||= load_user
+      end
+
+      def load_user
+        env[ACTIVE_USER]
+      end
+
+      def show_login_page(locals = {})
+        halt(401, erb(:login, :views => Spontaneous.application_dir('/views'), :locals => locals))
+      end
+    end
+  end
+end

data/lib/spontaneous/render.rb

@@ -5,15 +5,15 @@ module Spontaneous
   module Render
 
     class << self
-      def output_path(revision, page, format, extension = nil)
-        output_path_with_root(revision_root(revision), revision, page, format, extension)
+      def output_path(revision, page, format, extension = nil, template_dynamic = false)
+        output_path_with_root(revision_root(revision), revision, page, format, extension, template_dynamic)
       end
 
-      def output_path_with_root(root, revision, page, format, extension = nil)
+      def output_path_with_root(root, revision, page, format, extension = nil, template_dynamic = false)
         ext = ".#{format}"
-        ext += ".#{extension}" if extension
-
-        dir = root / format / page.path
+        ext += ".#{extension}" if extension && template_dynamic
+        segment = template_dynamic ? "dynamic" : (page.dynamic? ? "protected" : "static")
+        dir = root / segment / page.path
         path = dir / "/index#{ext}"
         path
       end
@@ -58,12 +58,15 @@ module Spontaneous
         @renderer ||= renderer_class.new(template_root)
       end
 
+
       def with_preview_renderer(&block)
         with_renderer(PreviewRenderer, &block)
       end
 
       def with_publishing_renderer(&block)
-        with_renderer(PublishingRenderer, &block)
+        with_render_cache {
+          with_renderer(PublishingRenderer, &block)
+        }
       end
 
       def with_published_renderer(&block)
@@ -97,6 +100,36 @@ module Spontaneous
       end
 
 
+      def with_render_cache
+        Thread.current[:_render_cache] = {}
+        yield if block_given?
+      ensure
+        Thread.current[:_render_cache] = nil
+      end
+
+      def render_cache
+        Thread.current[:_render_cache]
+      end
+
+      def render_cache_active?
+        !render_cache.nil?
+      end
+
+      def render_cache_key?(key)
+        return false unless render_cache_active?
+        render_cache.key?(key)
+      end
+
+      def render_cache_value(key)
+        return nil unless render_cache_active?
+        render_cache[key]
+      end
+
+      def render_cache_set_value(key, value)
+        return value unless render_cache_active?
+        render_cache[key] = value
+      end
+
       def template_root
         @template_root ||= Spontaneous.root / "templates"
       end
@@ -105,10 +138,10 @@ module Spontaneous
         ::File.join(template_root, *path)
       end
 
-      def template_root=(root)
-        @template_root = root
-        @renderer = nil
-      end
+      # def template_root=(root)
+      #   @template_root = root
+      #   @renderer = nil
+      # end
 
       def extension
         Spontaneous.template_ext
@@ -152,22 +185,30 @@ module Spontaneous
         end
       end
 
-      def render(content, format=:html, params={})
+      def render(content, format=:html, params={}, *args)
         Content.with_visible do
-          renderer.render_content(content, format || :html, params)
+          renderer.render_content(content, format || :html, params, *args)
+        end
+      end
+      def render_string(template_string, content, format=:html, params={}, *args)
+        Content.with_visible do
+          renderer.render_string(template_string, content, format || :html, params, *args)
         end
       end
     end
-    autoload :Engine, "spontaneous/render/engine"
-
-    autoload :Context, "spontaneous/render/context"
-
-    autoload :Renderer, "spontaneous/render/renderer"
-    autoload :PreviewRenderer, "spontaneous/render/preview_renderer"
-    autoload :PublishingRenderer, "spontaneous/render/publishing_renderer"
-    autoload :PublishedRenderer, "spontaneous/render/published_renderer"
-    autoload :DevelopmentRenderer, "spontaneous/render/development_renderer"
 
-    autoload :Format, "spontaneous/render/format"
+    autoload :Engine,               "spontaneous/render/engine"
+    autoload :ContextBase,          "spontaneous/render/context_base"
+    autoload :PreviewContext,       "spontaneous/render/preview_context"
+    autoload :PublishContext,       "spontaneous/render/publish_context"
+    autoload :RequestContext,       "spontaneous/render/request_context"
+    autoload :RenderCache,          "spontaneous/render/render_cache"
+    autoload :Renderer,             "spontaneous/render/renderer"
+    autoload :PreviewRenderer,      "spontaneous/render/preview_renderer"
+    autoload :PublishingRenderer,   "spontaneous/render/publishing_renderer"
+    autoload :PublishedRenderer,    "spontaneous/render/published_renderer"
+    autoload :DevelopmentRenderer,  "spontaneous/render/development_renderer"
+    autoload :Format,               "spontaneous/render/format"
+    autoload :Helpers,              "spontaneous/render/helpers"
   end
 end