spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/output/context.rb

@@ -1,32 +1,14 @@
 
 module Spontaneous::Output::Context
   autoload :RenderCache, 'spontaneous/output/context/render_cache'
+  autoload :Navigation,  'spontaneous/output/context/navigation'
 
   module ContextCore
     include RenderCache
-    attr_accessor :_renderer
-
-    def navigation(depth = 1, &block)
-      case depth
-      when 0, :root
-        root
-      when 1, :section
-        navigation_at_depth(1, &block)
-      else
-        navigation_at_depth(depth, &block)
-      end
-    end
+    include Navigation
 
-    def navigation_at_depth(depth = 1)
-      current_page = __target.page
-      __pages_at_depth(current_page, depth).each do |p|
-        yield(p, current_page.active?(p))
-      end
-    end
+    attr_accessor :_renderer, :site
 
-    def __pages_at_depth(origin_page, depth)
-      origin_page.at_depth(depth)
-    end
 
     def page
       __target.page
@@ -45,11 +27,11 @@ module Spontaneous::Output::Context
     end
 
     def root
-      Spontaneous::Site.root
+      site.home
     end
 
     def site_page(path)
-      Spontaneous::Site[path]
+      site[path]
     end
 
     def asset_environment
@@ -66,10 +48,6 @@ module Spontaneous::Output::Context
       "url(#{asset_path(path, options)})"
     end
 
-    def site
-      Spontaneous::Site.instance
-    end
-
     def publishing?
       false
     end
@@ -136,15 +114,9 @@ module Spontaneous::Output::Context
     end
 
     def __decode_params(param)
-      unless param.is_a?(String)
-        @_render_method ||= "to_#{__loader.format}".to_sym
-        if param.respond_to?(@_render_method)
-          param = param.send(@_render_method)
-        else
-          if param.respond_to?(:render)
-            param = __render_content(param) #render(param, param.template)
-          end
-        end
+      return param if param.is_a?(String)
+      if param.respond_to?(:render)
+        param = __render_content(param) #render(param, param.template)
       end
       param.to_s
     end
@@ -153,9 +125,9 @@ module Spontaneous::Output::Context
     # use of shared caches that are held by it.
     def __render_content(content)
       if content.respond_to?(:render_using)
-        content.render_using(_renderer, __format, self)
+        content.render_using(_renderer, __format, {}, self)
       else
-        content.render(__format, self)
+        content.render(__format, {}, self)
       end
     end
   end
@@ -186,7 +158,7 @@ module Spontaneous::Output::Context
       end
     end
 
-    def __pages_at_depth(origin_page, depth)
+    def __pages_at_depth(origin_page, depth, opts = {})
       _with_render_cache("pages_at_depth.#{origin_page.id}.#{depth}") do
         super
       end

data/lib/spontaneous/output/context/navigation.rb

@@ -0,0 +1,31 @@
+module Spontaneous::Output::Context
+  module Navigation
+    def navigation(opts = {}, &block)
+      depth = opts.delete(:depth) || 1
+      case depth
+      when 0, :root
+        root
+      when 1, :section
+        navigation_at_depth(1, opts, &block)
+      else
+        navigation_at_depth(depth, opts, &block)
+      end
+    end
+
+    def navigation_at_depth(depth, opts = {})
+      current_page = __target.page
+      pages = __pages_at_depth(current_page, depth, opts).map { |p| [p, current_page.active?(p)] }
+      if block_given?
+        pages.each do |p, active|
+          yield(p, active)
+        end
+      else
+        pages
+      end
+    end
+
+    def __pages_at_depth(origin_page, depth, opts = {})
+      origin_page.at_depth(depth, opts)
+    end
+  end
+end

data/lib/spontaneous/output/format.rb

@@ -65,6 +65,10 @@ module Spontaneous::Output
         @name
       end
 
+      def to_s
+        to_sym.to_s
+      end
+
       def extension(is_dynamic = false, dynamic_extension = Spontaneous::Output::Template.extension)
         if (override = @options[:extension])
           return normalise_extension(override.to_s)
@@ -99,8 +103,8 @@ module Spontaneous::Output
         @options[:postprocess]
       end
 
-      def context
-        Spontaneous::Site.context (helper_formats + [name]).uniq.compact
+      def context(site = Spontaneous.instance)
+        site.context (helper_formats + [name]).uniq.compact
       end
     end
 
@@ -121,20 +125,20 @@ module Spontaneous::Output
       content.model
     end
 
-    def render(params = {}, *args)
-      render_using(default_renderer, params, *args)
+    def render(params = {}, parent_context = nil)
+      render_using(default_renderer, params, parent_context)
     end
 
-    def render_using(renderer, params, *args)
+    def render_using(renderer, params = {}, parent_context = nil)
       before_render
-      output = render_page(renderer, params, *args)
+      output = render_page(renderer, params, parent_context)
       output = postprocess(output)
       after_render(output)
       output
     end
 
     def default_renderer
-      Spontaneous::Output.renderer
+      Spontaneous::Output.default_renderer
     end
 
     def before_render
@@ -150,21 +154,13 @@ module Spontaneous::Output
       output
     end
 
-    def render_page(renderer, params = {}, *args)
-      renderer.render(self, params, *args)
+    def render_page(renderer, params = {}, parent_context = nil)
+      renderer.render(self, params, parent_context)
     end
 
-    def publish_page(renderer, revision)
+    def publish_page(renderer, revision, transaction)
       rendered = render_using(renderer, {:revision => revision})
-      path = output_path(revision, rendered)
-      File.open(path, 'w') do |file|
-        case rendered
-        when IO
-          IO.copy_stream(rendered, file)
-        else
-          file.write(rendered.to_s)
-        end
-      end
+      transaction.store(self, renderer.is_dynamic_template?(rendered), rendered)
     end
 
     def output_path(revision, render)

data/lib/spontaneous/output/renderable.rb

@@ -0,0 +1,99 @@
+# The Renderable class is wrapped around the targets of the render context in
+# order to solve a particular problem around passing parameters/locals to
+# field & content render calls from within templates.
+
+# Say you wanted to render an image field but pass it some size parameters
+# in order to insert it at a particular size. You would do this in the template
+# like this:
+#
+#     ${ image.thumbnail(width: 50, height: 50) }
+#
+# this renders the image into the template using the following call stack:
+#
+#     context.__decode_params(context.image.thumbnail(width: 50, height: 50)).render(__format, {}, ...)
+#
+# The important thing to notice is that the params passed to the `thumbnail` method
+# are not passed into the final render and so will not result in the image being inserted
+# with the custom size params.
+#
+# Thie Renderable class solves this by intercepting all calls that return an object
+# that responds to #render and wrapping them in a Renderable instance that maintains
+# any params passed to them. So in the above method chain results gives:
+#
+#     context.image           #=> Renderable.new(page.image, {})
+#     context.image.thumbnail #=> Renderable.new(page.image.thumbnail, {width: 50, height: 50})
+#
+# and so the final render call will be made to the final Renderable instance which will
+# invoke page.image.thumbnail#render with the :width & :height locals it's saved from the
+# original template call, equivalent to:
+#
+#     page.image.thumbnail.render(__format, {width: 50, height: 50}, ...)
+
+module Spontaneous::Output
+  # A convenience method that tests to see if an object is 'renderable'
+  # that is it responds to #render
+  # and if so wraps it in a Renderable object with the given locals
+  def self.Renderable(obj, locals)
+    if obj.respond_to?(:render)
+      Renderable.new(obj, locals)
+    else
+      obj
+    end
+  end
+
+  class Renderable < BasicObject
+
+    def initialize(target, template_params = {})
+      @target, @template_params = target, (template_params || {})
+    end
+
+    def method_missing(name, *args)
+      result = nil
+      locals = __extract_locals__(args)
+
+      if ::Kernel.block_given?
+        # If we are passed a block then we want to make sure that any values
+        # yielded from that block are wrapped in Renderable instances
+        # if appropriate
+        block = ::Proc.new
+        result = @target.send(name, *args) do |*block_args|
+          renderable_args = block_args.map { |arg| ::Spontaneous::Output::Renderable(arg, locals) }
+          block.call(*renderable_args)
+        end
+      else
+        result = ::Spontaneous::Output::Renderable(@target.send(name, *args), locals)
+      end
+      result
+    end
+
+    def respond_to?(method_name, include_private = false)
+      @target.respond_to?(method_name, include_private) || super
+    end
+
+    alias_method :respond_to_missing?, :respond_to?
+
+    def render(format = :html, locals = {}, parent_context = nil)
+      @target.render(format, __render_locals__(locals), parent_context)
+    end
+
+    def render_using(renderer, format = :html, locals = {}, parent_context = nil)
+      @target.render_using(renderer, format, __render_locals__(locals), parent_context)
+    end
+
+    private
+
+    def __render_locals__(locals)
+      return @template_params if locals.nil?
+      locals.merge(@template_params || {})
+    end
+
+    # This is a non-destructive version of activesupport's Array#extract_options!
+    def __extract_locals__(args)
+      if args.last.is_a?(::Hash)
+        args.last
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/spontaneous/output/store.rb

@@ -0,0 +1,24 @@
+module Spontaneous::Output
+  module Store
+    autoload :Backend,     'spontaneous/output/store/backend'
+    autoload :File,        'spontaneous/output/store/file'
+    autoload :Moneta,      'spontaneous/output/store/moneta'
+    autoload :Revision,    'spontaneous/output/store/revision'
+    autoload :Store,       'spontaneous/output/store/store'
+    autoload :Transaction, 'spontaneous/output/store/transaction'
+
+    # Initializes a new store with the provided options
+    # Uses moneta as a unified interface to  except in the special case of the :File
+    # store which needs to work in a way compatible with the use of
+    # an frontend HTTP proxy, e.g. Nginx
+    def self.new(backend_class, options = {})
+      backend = case backend_class
+      when :File
+        File.new(options[:root])
+      else
+        Moneta.new(backend_class, options)
+      end
+      Store.new(backend)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Spontaneous::Output::Store
+  class Backend
+    unless defined?(STATIC_PATH)
+      STATIC_PATH, PROTECTED_PATH, DYNAMIC_PATH = %w(static protected dynamic).map(&:freeze)
+    end
+
+    def store_static(revision, key, template, transaction = nil)
+      store(revision, STATIC_PATH, key, template, transaction)
+    end
+
+    def store_protected(revision, key, template, transaction = nil)
+      store(revision, PROTECTED_PATH, key, template, transaction)
+    end
+
+    def store_dynamic(revision, key, template, transaction = nil)
+      store(revision, DYNAMIC_PATH, key, template, transaction)
+    end
+
+    def load_static(revision, key)
+      load(revision, STATIC_PATH, key)
+    end
+
+    def load_protected(revision, key)
+      load(revision, PROTECTED_PATH, key)
+    end
+
+    def load_dynamic(revision, key)
+      load(revision, DYNAMIC_PATH, key)
+    end
+
+    def output_key(output, dynamic = false)
+      path = output.page.path
+      ext  = output.extension(dynamic)
+      case path
+      when Spontaneous::SLASH
+        "/index#{ext}"
+      else
+        "#{path}#{ext}"
+      end
+    end
+
+    protected
+
+    def store(revision, partition, path, template, transaction)
+      raise NotImplementedError
+    end
+
+    def load(revision, partition, path)
+      raise NotImplementedError
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'fileutils'
+
+module Spontaneous::Output::Store
+  # The basic template storage backend.
+  #
+  # It stores static, protected & dynamic templates in different
+  # directories so that a reverse proxy conf can be pointed directly
+  # at the `static` area and (in theory) protected templates could
+  # be served using a "sendfile" header.
+  class File < Backend
+
+    def initialize(root)
+      @root = root
+    end
+
+    def add_revision(revision, keys)
+      ensure_dir revision_path(revision)
+    end
+
+    def revisions
+      dirs = ::Dir.entries(@root).select { |dir| /^[0-9]+$/ === dir }
+      dirs.map { |dir| dir.to_i(10) }.sort
+    end
+
+    def delete_revision(revision, keys = nil)
+      if (dir = revision_path(revision)) && ::File.exist?(dir)
+        ::FileUtils.rm_r(dir)
+      end
+    end
+
+    protected
+
+    def store(revision, partition, key, template, transaction)
+      ::File.open(path!(revision, partition, key, transaction), 'wb') { |f| f.write(template) }
+    end
+
+    def load(revision, partition, key)
+      read(path(revision, partition, key))
+    end
+
+    def read(path)
+      return nil unless ::File.exist?(path)
+      ::File.open(path, 'r:UTF-8')
+    end
+
+    def pad_revision(revision)
+      revision.to_s.rjust(5, "0")
+    end
+
+    def path!(revision, partition, key, transaction)
+      ensure_path path(revision, partition, key, transaction)
+    end
+
+    def path(revision, partition, path, transaction = nil)
+      transaction.push(key(revision, partition, path)) if transaction
+      ::File.join(revision_path(revision), partition, path)
+    end
+
+    def revision_path(revision)
+      ::File.join(@root, pad_revision(revision))
+    end
+
+    def ensure_path(path)
+      ensure_dir ::File.dirname(path)
+      path
+    end
+
+    def ensure_dir(dir)
+      FileUtils.mkdir_p(dir) unless ::File.exist?(dir)
+      dir
+    end
+
+    def key(revision, partition, path)
+      ::File.join(pad_revision(revision), partition, path)
+    end
+  end
+end