spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

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

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+require 'sass'
+
+module Spontaneous::Output::Helpers
+  module StylesheetHelper
+    extend self
+
+    def stylesheets(*args)
+      stylesheets = args.flatten
+      options = stylesheets.extract_options!
+      compress_stylesheets = (live? or (publishing? and options[:force_compression]))
+
+      return compressed_stylesheets(stylesheets) if compress_stylesheets
+
+      stylesheets.map do |stylesheet|
+        stylesheet_tag(stylesheet)
+      end.join("\n")
+    end
+
+    alias_method :stylesheet, :stylesheets
+
+    def stylesheet_tag(href)
+      href = "#{href}.css" unless href =~ /\.css$/o
+      %(<link rel="stylesheet" href="#{href}" />)
+    end
+
+    def compressed_stylesheets(stylesheets)
+      file_paths = stylesheets.map { |style| [style, S::Output::Assets.find_file("#{style}.scss", "#{style}.css")] }
+      invalid, file_paths = file_paths.partition { |url, path| path.nil? }
+      roots = Spontaneous.instance.paths.expanded(:public)
+
+      tags = []
+      css = file_paths.map { |url, path|
+        case path
+        when /\.scss$/o
+          load_paths = roots + [File.dirname(path), File.dirname(path) / "sass"]
+          ::Sass::Engine.for_file(path, {
+            :load_paths => load_paths,
+            :cache => false,
+            :style => :compressed
+          }).render
+        else
+          File.read(path)
+        end
+      }.join
+      compressed, hash = compress_css_string(css)
+      output_path = Spontaneous::Output::Assets.path_for(revision, "#{hash}.css")
+      FileUtils.mkdir_p(File.dirname(output_path))
+      File.open(output_path, "w") { |file| file.write(compressed) }
+      tags = [stylesheet_tag(Spontaneous::Output::Assets.url(hash))]
+      tags.join("\n")
+    end
+
+    def compress_css_string(css_string)
+      Spontaneous::Output::Assets::Compression.shine_compress_string(css_string, :css)
+    end
+
+    Spontaneous::Output::Helpers.register_helper(self, :html)
+  end
+end

data/lib/spontaneous/output/helpers.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Spontaneous::Output
+  module Helpers
+    # Helpers needs a separate helper registration mechanism outside of the Site scope
+    # because loading of these modules happens before we instantiate the site object.
+    # I don't want to pass calls to Site.register_helper here because Site based helpers
+    # should be disposed of with the Site instance whereas these core helpers should persist
+    def self.register_helper(helper_module, *formats)
+      if formats.empty?
+        registered_helpers[:*] << helper_module
+      else
+        formats.each do |format|
+          registered_helpers[format.to_sym] << helper_module
+        end
+      end
+    end
+
+    def self.registered_helpers
+      @registered_helpers ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    require 'spontaneous/output/helpers/stylesheet_helper'
+    require 'spontaneous/output/helpers/script_helper'
+    require 'spontaneous/output/helpers/classes_helper'
+    require 'spontaneous/output/helpers/conditional_comment_helper'
+  end
+end

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

@@ -0,0 +1,59 @@
+
+module Spontaneous::Output::Template
+  class PublishEngine
+    # 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?
+    end
+
+    def write_compiled_scripts=(state)
+      @engine.write_compiled_scripts = state if @engine.respond_to?(:write_compiled_scripts=)
+    end
+
+    def syntax
+      PublishSyntax
+    end
+
+    def roots
+      @engine.roots
+    end
+
+    def render(content, context, format = "html")
+      render_template(template_path(content, format), context, format)
+    end
+
+    def render_template(template_path, context, format = "html")
+      @engine.render(template_path, context, format)
+    end
+
+    def render_string(template_string, context, format = "html")
+      @engine.render_string(template_string, context, format)
+    end
+
+    def template_path(content, format)
+      content.template(format)
+    end
+
+    def template_exists?(root, template, format)
+      @engine.template_exists?(root, template, format)
+    end
+
+    def template_engine_class(cache)
+      ::Spontaneous::Output.template_engine_class(cache)
+    end
+  end
+
+  # Should be initialized with the path to the current rendered revision
+  class RequestEngine < PublishEngine
+    def syntax
+      RequestSyntax
+    end
+
+    def template_path(content, format)
+      path = content.path.gsub(%r{^/}, "")
+      path = "index" if path.empty?
+      path
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+
+module Spontaneous::Output::Template
+  # Renderers are responsible for creating contexts from objects & passing these
+  # onto the right template engine
+  # You only have one renderer instance per spontaneous role:
+  #
+  #   - editing/previewing : PreviewRenderer
+  #   - publishing         : PublishRenderer
+  #   - the live site      : PublishedRenderer
+  #
+  # these should be shared between requests/renders so that the
+  # caching can be effective
+
+  class Renderer
+    def initialize(cache = Spontaneous::Output.cache_templates?)
+      @cache = cache
+    end
+
+    def render(output, params = {})
+      Spontaneous::Content.with_visible do
+        engine.render(output.content, context(output, params), output.name.to_s)
+      end
+    end
+
+    def render_string(template_string, output, params = {})
+      Spontaneous::Content.with_visible do
+        engine.render_string(template_string, context(output, params), output.name.to_s)
+      end
+    end
+
+    def context(output, params)
+      context_class(output).new(output.content, params).tap do |context|
+        context.__renderer = self
+      end
+    end
+
+    def context_class(output)
+      context_cache[output.name] ||= generate_context_class(output)
+    end
+
+    def context_cache
+      @context_cache ||= {}
+    end
+
+    def generate_context_class(output)
+      context_class = Class.new(Spontaneous::Output.context_class) do
+        include Spontaneous::Output::Context::ContextCore
+        include output.context
+      end
+      context_extensions.each do |mod|
+        context_class.send :include, mod
+      end
+      context_class
+    end
+
+    def context_extensions
+      []
+    end
+
+    def write_compiled_scripts=(state)
+    end
+
+    def template_exists?(root, template, format)
+      engine.template_exists?(root, template, format)
+    end
+
+    def engine
+      @engine ||= Spontaneous::Output::Template::PublishEngine.new(Spontaneous::Site.paths(:templates), @cache)
+    end
+  end
+
+  class PublishRenderer < Renderer
+    def initialize(cache = Spontaneous::Output.cache_templates?)
+      super
+      Thread.current[:_render_cache] = {}
+    end
+
+    def render_cache
+      Thread.current[:_render_cache]
+    end
+
+    def write_compiled_scripts=(state)
+      engine.write_compiled_scripts = state
+    end
+
+    def context_extensions
+      [Spontaneous::Output::Context::PublishContext]
+    end
+  end
+
+  class RequestRenderer < Renderer
+    def engine
+      @engine ||= Spontaneous::Output::Template::RequestEngine.new(Spontaneous::Site.paths(:templates), @cache)
+    end
+  end
+
+  class PublishedRenderer < Renderer
+    def initialize(revision, cache = Spontaneous::Output.cache_templates?)
+      super(cache)
+      @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
+    rescue Cutaneous::UnknownTemplateError => e
+      template = publish_renderer.render(output, params)
+      render_string(template, output, params)
+    end
+
+    def static_template(template_path)
+      File.open(template_path)
+    end
+
+    def template_path(output, dynamic, request)
+      Spontaneous::Output.output_path(@revision, output, dynamic, request.request_method)
+    end
+
+    def engine
+      @engine ||= Spontaneous::Output::Template::RequestEngine.new(revision_root, @cache)
+    end
+
+    def publish_renderer
+      @publish_renderer ||= PublishRenderer.new
+    end
+
+    def revision_root
+      [Spontaneous::Site.revision_dir(@revision)/ "dynamic"]
+    end
+  end
+
+  class PreviewRenderer < Renderer
+    def render(output, params = {})
+      rendered = super(output)
+      request_renderer.render_string(rendered, output, params)
+    end
+
+    def render_string(template_string, output, params = {})
+      rendered = super(template_string, output)
+      request_renderer.render_string(rendered, output, params)
+    end
+
+    def request_renderer
+      @request_renderer ||= RequestRenderer.new
+    end
+  end
+end

data/lib/spontaneous/output/template.rb

@@ -0,0 +1,21 @@
+require 'spontaneous/output/template/renderer'
+require 'spontaneous/output/template/engine'
+
+module Spontaneous::Output
+  module Template
+
+    PublishSyntax = Cutaneous::FirstPassSyntax
+    RequestSyntax = Cutaneous::SecondPassSyntax
+
+
+    def extension
+      Cutaneous.extension
+    end
+
+    def is_dynamic?(template_string)
+      RequestSyntax.is_dynamic?(template_string)
+    end
+
+    extend self
+  end
+end

data/lib/spontaneous/output.rb

@@ -0,0 +1,163 @@
+
+module Spontaneous
+  module Output
+    def self.create(output_name, options = {})
+      options[:format] ||= generate_format(output_name)
+      c = (output_class(output_name, options)).tap do |klass|
+        klass.configure(output_name, options)
+      end
+    end
+
+    def self.generate_format(output_name)
+      if format_class_map.key?(output_name) or real_format?(output_name)
+        output_name
+      else
+        :html
+      end
+    end
+
+    def self.output_class(output_name, options)
+      format = options[:format]
+      unless (output_class = format_class_map[format])
+        output_class = create_output_class(format_class_map[:plain], format)
+        format_class_map[format] = output_class
+      end
+      c = Class.new(output_class)
+    end
+
+    def self.real_format?(format)
+      return format.to_sym if ::Rack::Mime::MIME_TYPES.key?(".#{format}")
+      nil
+    end
+
+    def self.create_output_class(baseclass, format)
+      output_class = Class.new(baseclass) do
+      end
+      self.register_format(output_class, format)
+      self.const_set(format.to_s.upcase, output_class)
+      output_class
+    end
+
+    def self.unknown_format?(format)
+      !format_class_map.key?(format.to_sym)
+    end
+
+    def self.format_class_map
+      @format_class_map ||= {}
+    end
+
+    def self.register_format(klass, *formats)
+      formats.each do |f|
+        format_class_map[f] = klass
+      end
+    end
+
+    def self.output_path(revision, output, template_dynamic = false, request_method = "GET")
+      output_path_with_root(revision_root(revision), revision, output, template_dynamic, request_method)
+    end
+
+    def self.output_path_with_root(root, revision, output, template_dynamic = false, request_method = "GET")
+      segment = case
+                when template_dynamic || output.dynamic?
+                  "dynamic"
+                when output.page.dynamic?(request_method)
+                  "protected"
+                else
+                  "static"
+                end
+      path = output.page.path
+      dir  = root / segment / path
+      ext  = output.extension(template_dynamic)
+
+      file = "#{dir}#{ext}"
+      file = dir / "/index#{ext}" if path == "/" # root is a special case, as always
+      file
+    end
+
+    # TODO: Is this ever used? Delete it & see what breaks
+    def self.revision_dir(revision=nil, root = nil)
+      Site.instance.revision_dir(revision, root)
+    end
+
+    def self.revision_root(revision)
+      Site.instance.revision_dir(revision)
+    end
+
+    def self.context_class
+      Cutaneous::Context
+    end
+
+    def self.cache_templates?
+      @cache_templates ||= Spontaneous.production?
+    end
+
+    def self.cache_templates=(value)
+      @cache_templates = value
+    end
+
+    def self.write_compiled_scripts=(state)
+      @write_compiled_scripts = !!state
+    end
+
+    def self.write_compiled_scripts?
+      @write_compiled_scripts = Spontaneous.production? unless defined?(@write_compiled_scripts)
+      @write_compiled_scripts
+    end
+
+    def self.template_engine_class(cache = cache_templates?)
+      if cache
+        cached_engine_class
+      else
+        uncached_engine_class
+      end
+    end
+
+    def self.cached_engine_class
+      Cutaneous::CachingEngine
+    end
+
+    def self.uncached_engine_class
+      Cutaneous::Engine
+    end
+
+    def self.renderer
+      @renderer ||= default_renderer
+    end
+
+    def self.renderer=(renderer)
+      @renderer = renderer
+    end
+
+    def self.default_renderer
+      Template::Renderer.new
+    end
+
+    def self.published_renderer(revision = Spontaneous::State.published_revision)
+      Template::PublishedRenderer.new(revision)
+    end
+
+    def self.preview_renderer
+      Template::PreviewRenderer.new
+    end
+
+    def self.template_exists?(root, template, format)
+      renderer.template_exists?(root, template, format)
+    end
+
+    def self.asset_url(file = nil)
+      File.join ["/rev", file].compact
+    end
+
+    def self.asset_path(revision = nil)
+      Spontaneous.revision_dir(revision) / asset_url
+    end
+
+    autoload :Template, "spontaneous/output/template"
+    autoload :Context,  "spontaneous/output/context"
+    autoload :Helpers,  "spontaneous/output/helpers"
+    autoload :Assets,   "spontaneous/output/assets"
+  end
+end
+
+# Loads in the default HTML & Plain formats
+require 'spontaneous/output/format'

data/lib/spontaneous/page.rb

@@ -11,6 +11,7 @@ module Spontaneous
     include Plugins::PageSearch
     include Plugins::Controllers
     include Plugins::Page::Request
+    include Plugins::Page::SiteTimestamps
 
     many_to_one :parent,   :class => Content, :reciprocal => :children
     one_to_many :children, :class => Content, :key => :parent_id, :reciprocal => :parent
@@ -86,7 +87,7 @@ module Spontaneous
     end
 
     def resolve_entry
-      owner.all_pieces.find { |e| e.id == self.id }
+      owner.all_contents.find { |e| e.id == self.id }
     end
 
     def page=(page)

data/lib/spontaneous/paths.rb

@@ -4,6 +4,10 @@ require 'pathname'
 
 module Spontaneous
   class Paths < ::Hash
+    def self.pad_revision_number(revision)
+      revision.to_s.rjust(5, "0")
+    end
+
     def initialize(root)
       @root = File.expand_path(root)
       super()
@@ -15,7 +19,8 @@ module Spontaneous
 
     def expanded(category)
       self[category].map do |path, glob|
-        path = Pathname.new(@root) + path
+        path = Pathname.new(path)
+        path = Pathname.new(@root) + path unless (path.absolute? && path.exist?)
         if path.exist?
           path = path.cleanpath
           path += glob if glob

data/lib/spontaneous/permissions/access_key.rb

@@ -5,16 +5,16 @@ module Spontaneous::Permissions
     plugin :timestamps
     many_to_one :user, :class => :'Spontaneous::Permissions::User'
 
-    def self.authenticate(key_id)
+    def self.authenticate(key_id, ip_address = nil)
       if key = self.for_id(key_id)
-        key.access!
+        key.access!(ip_address)
         return key
       end
       nil
     end
 
     def self.valid?(key_id, user)
-      return true if (key = self.for_id(key_id)) and key.user == user
+      return true if (key = self.for_id(key_id)) && (key.user == user) && (key.user.enabled?)
       false
     end
 
@@ -28,8 +28,8 @@ module Spontaneous::Permissions
       super
     end
 
-    def access!
-      self.update(:last_access_at => Time.now)
+    def access!(ip_address = nil)
+      self.update(:last_access_at => Time.now, :last_access_ip => ip_address)
     end
   end
 end