spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/render/context_base.rb

@@ -0,0 +1,143 @@
+# 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/format.rb

@@ -1,17 +1,32 @@
 
 module Spontaneous::Render
-  module Format; end
+  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
 
-
-    attr_reader :progress
-
-    def initialize(revision, pages, progress=nil)
-      @revision, @pages, @progress = revision, pages.find_all { |page| page.formats.include?(format) }, progress
+    def initialize(revision, page)
+      @revision, @page = revision, page
     end
 
     def format
@@ -20,20 +35,10 @@ module Spontaneous::Render
 
     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
+      render_page(@page)
       after_render
     end
 
-    def after_page_rendered(page)
-      progress.page_rendered(page) if progress
-    end
-
     def before_render; end
     def after_render; end
 
@@ -47,8 +52,8 @@ module Spontaneous::Render
 
     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)
+      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)

data/lib/spontaneous/render/helpers.rb

@@ -0,0 +1,14 @@
+# 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/helpers/html_helper.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+module Spontaneous::Render::Helpers
+  module HTMLHelper
+    extend self
+
+    def classes(*args)
+      args = args.flatten
+      optional = args.extract_options!
+      optional.each do |class_name, active|
+        args << class_name if active
+      end
+      return "" if args.empty?
+      %(class="#{args.join(" ")}")
+    end
+
+    def ie_only(version = nil)
+      ie_conditional_comment(version)
+    end
+
+    def ie_only_gt(version)
+      ie_conditional_comment(version, "gt")
+    end
+
+    def ie_only_gte(version)
+      ie_conditional_comment(version, "gte")
+    end
+
+    def ie_only_lt(version)
+      ie_conditional_comment(version, "lt")
+    end
+
+    def ie_only_lte(version)
+      ie_conditional_comment(version, "lte")
+    end
+
+    def ie_only_end
+      "<![endif]-->"
+    end
+
+    def not_ie
+       "<!--[if !IE]> -->"
+    end
+
+    def not_ie_end
+       "<!-- <![endif]-->"
+    end
+
+    def ie_conditional_comment(version = nil, test = nil)
+      ie_conditional_comment_start(version, test)
+    end
+
+    def ie_conditional_comment_start(version = nil, test = nil)
+      ["<!--[if ", test_for_version(version, test), "]>"].join
+    end
+
+    def test_for_version(version, test)
+      if version.is_a?(Range)
+        version = version.to_a
+        lower = "(#{test_for_version(version.first, "gte")})"
+        upper = "(#{test_for_version(version.last,  "lte")})"
+        [lower, upper].join("&")
+      else
+        [test, "IE", version].compact.join(" ")
+      end
+    end
+
+  end
+end

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

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

@@ -0,0 +1,16 @@
+# 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/preview_context.rb

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

data/lib/spontaneous/render/preview_renderer.rb

@@ -12,6 +12,12 @@ module Spontaneous
 
         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

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

@@ -7,16 +7,18 @@ module Spontaneous
       NGINX_ACCEL_REDIRECT = "X-Accel-Redirect"
 
       def render_content(content, format=:html, params = {})
-        request = params[:request]
+        request  = params[:request]
         response = params[:response]
-        headers = request.env
-        render = nil
+        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(Content.revision, content, format, extension)
+          template = Spontaneous::Render.output_path(revision, content, format, extension, true)
 
           if File.exists?(template)
             render = request_renderer.render_file(template, content, format, params)
@@ -25,17 +27,10 @@ module Spontaneous
             # 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(Content.revision, content, format)
+            template = Spontaneous::Render.output_path(revision, content, format)
 
             if File.exists?(template)
-              # first check to see if we're behind an nginx proxy
-              if headers.key?(NGINX_DETECT_HEADER)
-                # if so, then use nginx's sendfile mechanism to return the file
-                response.headers[NGINX_ACCEL_REDIRECT] = Spontaneous::Render.redirect_path(Content.revision, content, format)
-              else
-                # if not, then return the file ourselves
-                render = File.read(template)
-              end
+              render = File.open(template)
             else
               # and if all else fails, just re-render the damn thing
               render = rerender(content, format, params)
@@ -49,6 +44,10 @@ module Spontaneous
         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

@@ -7,6 +7,9 @@ module Spontaneous
       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