spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/output/store/moneta.rb

@@ -0,0 +1,117 @@
+require 'moneta'
+require 'json'
+
+module Spontaneous::Output::Store
+  # Implements the template store API on top of a Moneta key-value store.
+  #
+  # Unlike the File backend, we don't need to differentiate the storage
+  # locations of static, protected & dynamic templates because no integration
+  # with Nginx (etc) is possible
+  #
+  # This is not thread safe because the operations at the revision level aren't
+  # thread safe, although the simple load/store template operations are. In the
+  # current use case this isn't a problem & isn't likely to be one - template
+  # generation is a part of publishing & the logical way to speed up publishing
+  # is to split the rendering of pages across multiple processes in a map-reduce
+  # pattern which would leave the Transaction#commit & Transaction#rollback
+  # operations, which use the revision level methods, as the `reduce` phase
+  # which is single threaded whilst the template inserts would need to support
+  # concurrent access.
+  class Moneta < Backend
+    REVISION_SEP = ":".freeze
+
+    attr_reader :backend
+
+    def initialize(name, options = {})
+      @backend = ::Moneta.build do
+        adapter name, options
+      end
+    end
+
+    def add_revision(revision, keys)
+      save_revisions(revisions.push(revision))
+      @backend.store(revision_key(revision), serialize(keys))
+    end
+
+    def revisions
+      unserialize(@backend.load(revisions_key)) || []
+    end
+
+    def delete_revision(revision, keys = nil)
+      revision_list = revisions
+      if revision_list.delete(revision)
+        keys ||= unserialize @backend.load(revision_key(revision))
+        save_revisions(revision_list)
+      end
+      @backend.delete(revision_key(revision))
+      # want to delete the keys even if the revision hasn't been created
+      # this covers the case of a transaction rollback where
+      # we have a list of keys but no committed revision
+      keys.each do |key|
+        @backend.delete(key)
+      end if keys
+    end
+
+    def revision_key(revision)
+      ":revision:#{revision}"
+    end
+
+    def revisions_key
+      ":revisions:"
+    end
+
+    protected
+
+    # The Template class wraps a String template response with IO characteristics
+    # based on StringIO & also supplies File-like characteristics by
+    # providing a #path method.
+    #
+    # The IO methods provide an #each method for Rack, and
+    # the #path method can be used by the rendering engine for caching.
+    #
+    # We don't provide a #to_path method for Rack because there
+    # is no file represantation of this object for passing to a proxy
+    # server
+    class Template < StringIO
+      def initialize(template, path)
+        @path = path
+        super(template)
+      end
+
+      attr_reader :path
+    end
+
+    def store(revision, partition, path, template, transaction)
+      key = key_for(revision, partition, path)
+      transaction.push(key) if transaction
+      @backend.store(key, template)
+    end
+
+    def load(revision, partition, path)
+      if (template = @backend.load(key_for(revision, partition, path)))
+        return Template.new(template, path_for(revision, partition, path))
+      end
+      nil
+    end
+
+    def key_for(revision, partition, path)
+      [revision, partition, path].join(REVISION_SEP)
+    end
+
+    def path_for(revision, partition, path)
+      ::File.join(Spontaneous::SLASH, revision.to_s, partition, path)
+    end
+
+    def serialize(obj)
+      Spontaneous::JSON.encode(obj)
+    end
+
+    def unserialize(obj)
+      Spontaneous::JSON.parse(obj)
+    end
+
+    def save_revisions(revisions)
+      @backend.store(revisions_key, serialize(revisions.sort))
+    end
+  end
+end

data/lib/spontaneous/output/store/revision.rb

@@ -0,0 +1,34 @@
+module Spontaneous::Output::Store
+  class Revision
+    attr_reader :revision, :store
+
+
+    def initialize(revision, store)
+      @revision, @store = revision, store
+    end
+
+    def transaction
+      Transaction.new(@revision, @store)
+    end
+
+    # Tests for the existance of a static template
+    # This provides a way to short-cut the render step as
+    # if this returns a non-nil result then we can reply
+    # directly to the request with this template & skip the
+    # render step
+    def static_template(output)
+      key = @store.output_key(output)
+      @store.load_protected(@revision, key) || @store.load_static(@revision, key)
+    end
+
+    # Return a template for the given output
+    def dynamic_template(output, request = nil)
+      key = @store.output_key(output, true)
+      @store.load_dynamic(@revision, key)
+    end
+
+    def delete
+      @store.delete_revision(@revision)
+    end
+  end
+end

data/lib/spontaneous/output/store/store.rb

@@ -0,0 +1,15 @@
+module Spontaneous::Output::Store
+  class Store
+    def initialize(backing)
+      @backing = backing
+    end
+
+    def revision(revision)
+      Spontaneous::Output::Store::Revision.new(revision, @backing)
+    end
+
+    def revisions
+      @backing.revisions
+    end
+  end
+end

data/lib/spontaneous/output/store/transaction.rb

@@ -0,0 +1,44 @@
+module Spontaneous::Output::Store
+  # A Transaction is a write-only view of the template store.
+  # It provides #commit & #rollback mechanisms that function
+  # like their DB equivalents, either preserving or removing the
+  # modifications made.
+  class Transaction
+    attr_reader :revision
+
+    def initialize(revision, store)
+      @revision, @store = revision, store
+      @index = []
+      @committed = false
+    end
+
+    def store(output, dynamic, template)
+      key = @store.output_key(output, dynamic)
+      case
+      when dynamic || output.dynamic? # dynamic
+        @store.store_dynamic(@revision, key, template, self)
+      when output.page.dynamic? # protected
+        @store.store_protected(@revision, key, template, self)
+      else # static
+        @store.store_static(@revision, key, template, self)
+      end
+    end
+
+    # Stores call this method to register the keys
+    # they write to their backends. This is necessary
+    # because we don't want to limit our backends to those
+    # that are able to return keys based on a glob
+    def push(key)
+      @index.push(key)
+    end
+
+    def commit
+      @store.add_revision(@revision, @index)
+      @committed = true
+    end
+
+    def rollback
+      @store.delete_revision(@revision, @index) unless @committed
+    end
+  end
+end

data/lib/spontaneous/output/template/engine.rb

@@ -4,7 +4,9 @@ module Spontaneous::Output::Template
     # Should be initialized with the Site template roots
     def initialize(template_roots, cache = Spontaneous::Output.cache_templates?)
       @engine = template_engine_class(cache).new(template_roots, syntax)
-      self.write_compiled_scripts = Spontaneous::Output.write_compiled_scripts?
+      # disabled until I figure out where to write compiled scripts when using a
+      # non-File based template store
+      self.write_compiled_scripts = false # Spontaneous::Output.write_compiled_scripts?
     end
 
     def write_compiled_scripts=(state)
@@ -19,29 +21,37 @@ module Spontaneous::Output::Template
       @engine.roots
     end
 
-    def render(content, context, format = "html")
+    def render(content, context, format = :html)
       render_template(template_path(content, format), context, format)
     end
 
-    def render_template(template_path, context, format = "html")
+    def render_template(template_path, context, format = :html)
       @engine.render(template_path, context, format)
     end
 
-    def render_string(template_string, context, format = "html")
+    def render_string(template_string, context, format = :html)
       @engine.render_string(template_string, context, format)
     end
 
     def template_path(content, format)
-      content.template(format)
+      content.template(format, self)
     end
 
-    def template_exists?(root, template, format)
-      @engine.template_exists?(root, template, format)
+    def template_exists?(template, format)
+      @engine.template_exists?(template, format)
+    end
+
+    def template_location(template, format)
+      @engine.template_location(template, format)
     end
 
     def template_engine_class(cache)
       ::Spontaneous::Output.template_engine_class(cache)
     end
+
+    def dynamic_template?(template_string)
+      @engine.dynamic_template?(template_string)
+    end
   end
 
   # Should be initialized with the path to the current rendered revision

data/lib/spontaneous/output/template/renderer.rb

@@ -12,24 +12,26 @@ module Spontaneous::Output::Template
   # caching can be effective
 
   class Renderer
-    def initialize(cache = Spontaneous::Output.cache_templates?)
+    def initialize(site, cache = Spontaneous::Output.cache_templates?)
+      @site  = site
       @cache = cache
     end
 
-    def render(output, params = {})
+    def render(output, params = {}, parent_context = nil)
       output.model.with_visible do
-        engine.render(output.content, context(output, params), output.name)
+        engine.render(output.content, context(output, params, parent_context), output.name)
       end
     end
 
-    def render_string(template_string, output, params = {})
+    def render_string(template_string, output, params = {}, parent_context = nil)
       output.model.with_visible do
-        engine.render_string(template_string, context(output, params), output.name)
+        engine.render_string(template_string, context(output, params, parent_context), output.name)
       end
     end
 
-    def context(output, params)
-      context_class(output).new(output.content, params).tap do |context|
+    def context(output, params, parent)
+      context_class(output).new(Spontaneous::Output::Renderable.new(output.content), params, parent).tap do |context|
+        context.site = @site
         context._renderer = renderer_for_context
       end
     end
@@ -51,9 +53,10 @@ module Spontaneous::Output::Template
     end
 
     def generate_context_class(output)
+      site = @site
       context_class = Class.new(Spontaneous::Output.context_class) do
         include Spontaneous::Output::Context::ContextCore
-        include output.context
+        include output.context(site)
       end
       context_extensions.each do |mod|
         context_class.send :include, mod
@@ -68,17 +71,37 @@ module Spontaneous::Output::Template
     def write_compiled_scripts=(state)
     end
 
-    def template_exists?(root, template, format)
-      engine.template_exists?(root, template, format)
+    def template_exists?(template, format)
+      engine.template_exists?(template, format)
+    end
+
+    def template_location(template, format)
+      engine.template_location(template, format)
+    end
+
+    def is_dynamic_template?(template_string)
+      second_pass_engine.dynamic_template?(template_string)
+    end
+
+    def is_model?(klass)
+      klass < @site.model
     end
 
     def engine
-      @engine ||= Spontaneous::Output::Template::PublishEngine.new(Spontaneous::Site.paths(:templates), @cache)
+      @engine ||= create_engine(:PublishEngine)
+    end
+
+    def second_pass_engine
+      @second_pass_engine ||= create_engine(:RequestEngine)
+    end
+
+    def create_engine(engine_class, template_roots = @site.paths(:templates))
+      Spontaneous::Output::Template.const_get(engine_class).new(template_roots, @cache)
     end
   end
 
   class PublishRenderer < Renderer
-    def initialize(cache = Spontaneous::Output.cache_templates?)
+    def initialize(site, cache = Spontaneous::Output.cache_templates?)
       super
       Thread.current[:_render_cache] = {}
     end
@@ -87,8 +110,9 @@ module Spontaneous::Output::Template
       Thread.current[:_render_cache]
     end
 
+    # Disabled for moment
     def write_compiled_scripts=(state)
-      engine.write_compiled_scripts = state
+      engine.write_compiled_scripts = false # state
     end
 
     def context_extensions
@@ -98,68 +122,70 @@ module Spontaneous::Output::Template
 
   class RequestRenderer < Renderer
     def engine
-      @engine ||= Spontaneous::Output::Template::RequestEngine.new(Spontaneous::Site.paths(:templates), @cache)
+      @engine ||= create_engine(:RequestEngine)
     end
   end
 
   class PublishedRenderer < Renderer
-    def initialize(revision, cache = Spontaneous::Output.cache_templates?)
-      super(cache)
+    def initialize(site, revision, cache = Spontaneous::Output.cache_templates?)
+      super(site, cache)
       @revision = revision
+      @output_store = @site.output_store.revision(@revision)
     end
 
-    def render(output, params = {})
-      request  = params[:request]
-      response = params[:response]
-      headers  = request.env
-      # Test for static template
-      path = template_path(output, false, request)
-      return static_template(path) if ::File.exist?(path)
-      # Attempt to render a published template
-      super
+    def render(output, params = {}, parent_context = nil)
+      render!(output, params, parent_context)
     rescue Cutaneous::UnknownTemplateError => e
-      template = publish_renderer.render(output, params)
-      render_string(template, output, params)
+      render_on_demand(output, params, parent_context)
     end
 
-    def static_template(template_path)
-      File.open(template_path)
+    def render!(output, params, parent_context)
+      if (template = @output_store.static_template(output))
+        return template
+      end
+      # Attempt to render a published template
+      if (template = @output_store.dynamic_template(output))
+        return engine.render_template(template, context(output, params, parent_context), output.name)
+      end
+      logger.warn("missing template for #{output}")
+      render_on_demand(output, params, parent_context)
     end
 
-    def template_path(output, dynamic, request)
-      Spontaneous::Output.output_path(@revision, output, dynamic, request.request_method)
+    def render_on_demand(output, params, parent_context)
+      template = publish_renderer.render(output, params)
+      render_string(template, output, params)
     end
 
     def engine
-      @engine ||= Spontaneous::Output::Template::RequestEngine.new(revision_root, @cache)
+      @engine ||= create_engine(:RequestEngine, revision_root)
     end
 
     def publish_renderer
-      @publish_renderer ||= PublishRenderer.new
+      @publish_renderer ||= PublishRenderer.new(@site)
     end
 
     def revision_root
-      [Spontaneous::Site.revision_dir(@revision)/ "dynamic"]
+      [@site.revision_dir(@revision)/ "dynamic"]
     end
   end
 
   class PreviewRenderer < Renderer
-    def render(output, params = {})
+    def render(output, params = {}, parent_context = nil)
       rendered = super(output)
-      request_renderer.render_string(rendered, output, params)
+      request_renderer.render_string(rendered, output, params, parent_context)
     end
 
-    def render_string(template_string, output, params = {})
+    def render_string(template_string, output, params = {}, parent_context = nil)
       rendered = super(template_string, output)
-      request_renderer.render_string(rendered, output, params)
+      request_renderer.render_string(rendered, output, params, parent_context)
     end
 
     def renderer_for_context
-      @renderer_for_context ||= PublishRenderer.new(@cache)
+      @renderer_for_context ||= PublishRenderer.new(@site, @cache)
     end
 
     def request_renderer
-      @request_renderer ||= RequestRenderer.new(@cache)
+      @request_renderer ||= RequestRenderer.new(@site, @cache)
     end
   end
 end