spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/cutaneous.rb

@@ -1,48 +0,0 @@
-
-module Cutaneous
-  def self.template_path(filename, format)
-    Spontaneous.template_path(template_name(filename, format))
-  end
-
-  def self.template_name(filename, format)
-    "#{filename}.#{format}.#{self.extension}"
-  end
-
-  # this is basicially the API that any templating engine has to provide
-  def self.extension
-    'cut'
-  end
-
-  def self.preview_renderer
-    PreviewRenderer
-  end
-
-  def self.publishing_renderer
-    PublishRenderer
-  end
-
-  def self.request_renderer
-    RequestRenderer
-  end
-
-  def self.is_dynamic?(render)
-    RequestTokenParser.is_dynamic?(render)
-  end
-
-
-  autoload :ContextHelper, "cutaneous/context_helper"
-  autoload :PreviewContext, "cutaneous/preview_context"
-  autoload :PublishContext, "cutaneous/publish_context"
-  autoload :RequestContext, "cutaneous/request_context"
-
-  autoload :Renderer, "cutaneous/renderer"
-  autoload :PublishRenderer, "cutaneous/publish_renderer"
-  autoload :RequestRenderer, "cutaneous/request_renderer"
-  autoload :PreviewRenderer, "cutaneous/preview_renderer"
-
-  autoload :TokenParser, "cutaneous/token_parser"
-  autoload :PublishTokenParser, "cutaneous/publish_token_parser"
-  autoload :RequestTokenParser, "cutaneous/request_token_parser"
-  autoload :PublishTemplate, "cutaneous/publish_template"
-  autoload :RequestTemplate, "cutaneous/request_template"
-end

data/lib/spontaneous/render/context_base.rb

@@ -1,143 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous::Render
-  module ContextBase
-    include Spontaneous::Render::Helpers
-
-    attr_reader :_format, :_target, :_locals
-
-    def initialize(target, format, parent={})
-      @_target, @_format = target, format
-      _update(parent)
-    end
-
-    def show_errors?
-      Spontaneous.development?
-    end
-
-    alias_method :format, :_format
-
-    def root
-      Spontaneous::Site.root
-    end
-
-    def navigation(depth = 1, &block)
-      case depth
-      when 0, :root
-        root
-      when 1, :section
-        navigation_at_depth(1, &block)
-      end
-    end
-
-    def navigation_at_depth(depth = 1)
-      _pages_at_depth(self.page, depth).each do |p|
-        yield(p, self.page.active?(p))
-      end
-    end
-
-    def _pages_at_depth(origin_page, depth)
-      origin_page.at_depth(depth)
-    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.owner.pieces.first == self
-    end
-
-    def last?
-      _target.owner.pieces.last == self
-    end
-
-    def render_content
-      _target.map do |c|
-        c.render(_format, self)
-      end.join("\n")
-    end
-
-    def render(format, *args)
-      _target.render(format, self, *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(parent)
-      if parent.is_a?(Hash)
-        _update_with_hash(parent)
-      else
-        parent.instance_variables.reject { |var| /^@_/ === var.to_s }.each do |variable|
-          instance_variable_set(variable, parent.instance_variable_get(variable))
-        end
-        _update_with_hash(parent._locals) if parent.respond_to?(:_locals)
-      end
-      self
-    end
-
-    def _update_with_hash(hash)
-      @_locals = hash
-      hash.each do |key, val|
-        singleton_class.__send__(:define_method, key) { val }
-      end
-    end
-  end
-end
-

data/lib/spontaneous/render/development_renderer.rb

@@ -1,14 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

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

data/lib/spontaneous/render/format.rb

@@ -1,75 +0,0 @@
-
-module Spontaneous::Render
-  module Format
-    def self.for(format)
-      format_class = nil
-      begin
-        format_class = self.const_get("#{format.to_s.camelize}")
-      rescue NameError => e
-        # Assume that the missing format is compatilble with the standard HTML
-        # format in that each page generates a separate, self contained, file
-        # .. probably true in most cases
-        format_class = Class.new(Spontaneous::Render::FormatBase)
-        self.const_set(format.to_s.camelize, format_class)
-      end
-      format_class
-    end
-
-    def self.formats
-      self.constants.map { |const| const.to_s.downcase.to_sym }
-    end
-  end
-
-  class FormatBase
-    def self.format
-      @format ||= self.name.demodulize.downcase.to_sym
-    end
-
-    def initialize(revision, page)
-      @revision, @page = revision, page
-    end
-
-    def format
-      self.class.format
-    end
-
-    def render
-      before_render
-      render_page(@page)
-      after_render
-    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
-      template_dynamic = Spontaneous.template_engine.is_dynamic?(output)
-      path = Spontaneous::Render.output_path(@revision, page, format, renderer.extension, template_dynamic)
-
-      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/helpers/script_helper.rb

@@ -1,17 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Render::Helpers
-  module ScriptHelper
-    extend self
-
-    def script(*args)
-      scripts = args.flatten
-      scripts.map do |script|
-        %(<script type="text/javascript" src="#{script}.js"></script>)
-      end.join("\n")
-    end
-
-    alias_method :scripts, :script
-  end
-end
-

data/lib/spontaneous/render/helpers/stylesheet_helper.rb

@@ -1,16 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Render::Helpers
-  module StylesheetHelper
-    extend self
-
-    def stylesheet(*args)
-      stylesheets = args
-      stylesheets.map do |stylesheet|
-        %(<link rel="stylesheet" href="#{stylesheet}.css" />)
-      end.join("\n")
-    end
-
-    alias_method :stylesheets, :stylesheet
-  end
-end

data/lib/spontaneous/render/helpers.rb

@@ -1,14 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Render
-  module Helpers
-    autoload :StylesheetHelper, 'spontaneous/render/helpers/stylesheet_helper'
-    autoload :ScriptHelper, 'spontaneous/render/helpers/script_helper'
-    autoload :HTMLHelper, 'spontaneous/render/helpers/html_helper'
-
-    include StylesheetHelper
-    include ScriptHelper
-    include HTMLHelper
-  end
-end
-

data/lib/spontaneous/render/preview_context.rb

@@ -1,8 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous::Render
-  module PreviewContext
-    include Spontaneous::Render::ContextBase
-  end # PreviewContext
-end # Spontaneous::Render

data/lib/spontaneous/render/preview_renderer.rb

@@ -1,24 +0,0 @@
-# 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
-
-      def render_string(template_string, content, format=:html, params = {})
-        template = preview_renderer.render_string(template_string, content, format, params)
-        result = request_renderer.render_string(template, content, format, params)
-        result
-      end
-    end # PreviewRenderer
-  end # Render
-end # Spontaneous
-

data/lib/spontaneous/render/publish_context.rb

@@ -1,22 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous::Render
-  module PublishContext
-    include Spontaneous::Render::ContextBase
-    include Spontaneous::Render::RenderCache
-
-    def root
-      _with_render_cache("site.root") do
-        super
-      end
-    end
-
-
-    def _pages_at_depth(origin_page, depth)
-      _with_render_cache("pages_at_depth.#{origin_page.id}.#{depth}") do
-        super
-      end
-    end
-  end # PublishContext
-end # Spontaneous::Render

data/lib/spontaneous/render/published_renderer.rb

@@ -1,53 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Render
-    class PublishedRenderer < Renderer
-      NGINX_DETECT_HEADER = "X-Nginx"
-      NGINX_ACCEL_REDIRECT = "X-Accel-Redirect"
-
-      def render_content(content, format=:html, params = {})
-        request  = params[:request]
-        response = params[:response]
-        headers  = request.env
-        revision = Content.revision
-        render   = nil
-
-        if Spontaneous.development? and Spontaneous.config.rerender_pages
-          # in dev mode we just want to render the page dynamically, skipping the cached version
-          render = rerender(content, format, params)
-        else
-          # first test for dynamic template
-          template = Spontaneous::Render.output_path(revision, content, format, extension, true)
-
-          if File.exists?(template)
-            render = request_renderer.render_file(template, content, format, params)
-          else
-
-            # if no dynamic template exists then try for a static file
-            # this case will normally be handled by the proxy server (nginx, apache...)
-            # in production environments
-            template = Spontaneous::Render.output_path(revision, content, format)
-
-            if File.exists?(template)
-              render = File.open(template)
-            else
-              # and if all else fails, just re-render the damn thing
-              render = rerender(content, format, params)
-            end
-          end
-        end
-        render
-      end
-
-      def rerender(content, format = :html, params = {})
-        template = publishing_renderer.render_file(content.template(format), content, format)
-        request_renderer.render_string(template, content, format, params)
-      end
-
-      def render_string(template_string, content, format=:html, params = {})
-        request_renderer.render_string(template_string, content, format, params)
-      end
-    end # PublishedRenderer
-  end # Render
-end # Spontaneous

data/lib/spontaneous/render/publishing_renderer.rb

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

data/lib/spontaneous/render/render_cache.rb

@@ -1,26 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous::Render
-  module RenderCache
-    def _render_cache_value(key)
-      Spontaneous::Render.render_cache_value(key)
-    end
-
-    def _render_cache_set_value(key, value)
-      Spontaneous::Render.render_cache_set_value(key, value)
-    end
-
-    def _render_cache_key?(key)
-      Spontaneous::Render.render_cache_key?(key)
-    end
-
-    def _with_render_cache(key, &value_block)
-      if _render_cache_key?(key)
-        self._render_cache_value(key)
-      else
-        self._render_cache_set_value(key, yield)
-      end
-    end
-  end # RenderCache
-end # Spontaneous::Render

data/lib/spontaneous/render/renderer.rb

@@ -1,50 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous
-  module Render
-    class Renderer
-
-      attr_reader :template_root
-
-      def initialize(template_root)
-        @template_root = template_root
-      end
-
-      def render_content(content, format=:html, params = {})
-        # overwrite in subclasses
-      end
-
-      def render_string(template_string, content, format=:html, params = {})
-        # overwrite in subclasses
-      end
-
-      def template_file(filename, format)
-        Render.template_file(template_root, filename, format)
-      end
-
-      def extension
-        Spontaneous.template_engine.extension
-      end
-
-      # protected
-
-      def preview_renderer
-        Spontaneous.template_engine.preview_renderer.new(template_root, cache?)
-      end
-
-      def publishing_renderer
-        Spontaneous.template_engine.publishing_renderer.new(template_root, cache?)
-      end
-
-      def request_renderer
-        Spontaneous.template_engine.request_renderer.new(template_root, cache?)
-      end
-
-      def cache?
-        Spontaneous::Render.cache_templates?
-      end
-    end # Renderer
-  end  # Render
-end  # Spontaneous
-

data/lib/spontaneous/render/request_context.rb

@@ -1,8 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous::Render
-  module RequestContext
-    include Spontaneous::Render::ContextBase
-  end # RequestContext
-end # Spontaneous::Render