spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/output/context.rb

@@ -1,7 +1,10 @@
 
 module Spontaneous::Output::Context
+  autoload :RenderCache, 'spontaneous/output/context/render_cache'
+
   module ContextCore
-    attr_accessor :__renderer
+    include RenderCache
+    attr_accessor :_renderer
 
     def navigation(depth = 1, &block)
       case depth
@@ -37,10 +40,36 @@ module Spontaneous::Output::Context
       Spontaneous.development?
     end
 
+    def development?
+      Spontaneous.development?
+    end
+
     def root
       Spontaneous::Site.root
     end
 
+    def site_page(path)
+      Spontaneous::Site[path]
+    end
+
+    def asset_environment
+      _with_render_cache('asset.environment') do
+        Spontaneous::Asset::Environment.new(self)
+      end
+    end
+
+    def asset_path(path, options = {})
+      asset_environment.find(path, options).try(:first)
+    end
+
+    def asset_url(path, options = {})
+      "url(#{asset_path(path, options)})"
+    end
+
+    def site
+      Spontaneous::Site.instance
+    end
+
     def publishing?
       false
     end
@@ -57,6 +86,10 @@ module Spontaneous::Output::Context
       content.map { |c| yield(c) } if block_given?
     end
 
+    def this
+      __target
+    end
+
     def content
       __target.iterable
     end
@@ -87,6 +120,17 @@ module Spontaneous::Output::Context
       __target.owner.pieces.last == self
     end
 
+    # template takes an existing first-pass template, converts it to a second pass template
+    # and then returns the result for inclusion.
+    # This lets you share templates between the publish step and the request step.
+    # Useful for things like search results where you want to list the results using the same
+    # layout that you used in the static list
+    def template(template_path)
+      __loader.template(template_path).convert(Spontaneous::Output::Template::RequestSyntax)
+    end
+
+    alias_method :defer, :template
+
     def __format
       __loader.format
     end
@@ -109,37 +153,14 @@ 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)
       end
     end
   end
 
-  module RenderCache
-    def _render_cache_value(key)
-      __renderer.render_cache[key]
-    end
-
-    def _render_cache_set_value(key, value)
-      __renderer.render_cache[key] = value
-    end
-
-    def _render_cache_key?(key)
-      __renderer.render_cache.key?(key)
-    end
-
-    def _with_render_cache(key, &value_block)
-      if _render_cache_key?(key)
-        _render_cache_value(key)
-      else
-        _render_cache_set_value(key, yield)
-      end
-    end
-  end
-
   module PublishContext
-    include RenderCache
 
     def root
       _with_render_cache("site.root") do
@@ -147,15 +168,21 @@ module Spontaneous::Output::Context
       end
     end
 
-    def compressed_scripts(scripts)
+    def site_page(path)
+      _with_render_cache("site_page.#{path}") do
+        super
+      end
+    end
+
+    def scripts(*scripts)
       _with_render_cache(scripts.join(",")) do
-        super(scripts)
+        super
       end
     end
 
-    def compressed_stylesheets(stylesheets)
+    def stylesheets(*stylesheets)
       _with_render_cache(stylesheets.join(",")) do
-        super(stylesheets)
+        super
       end
     end
 
@@ -175,5 +202,4 @@ module Spontaneous::Output::Context
 
   module RequestContext
   end
-
 end

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

@@ -7,67 +7,23 @@ module Spontaneous::Output::Helpers
     extend self
 
     def scripts(*args)
-      scripts = args.flatten
-      options = scripts.extract_options!
-      compress = (live? or (publishing? and options[:force_compression]))
-      return compressed_scripts(scripts) if compress
-      scripts.map { |script| script_tag(script)  }.join("\n")
+      script_urls(*args).map { |script|
+        script_tag(script)
+      }.join("\n")
+    end
+
+    def script_urls(*args)
+      options = args.extract_options!
+      options.update(:development => development?)
+      asset_environment.js(args.flatten, options)
     end
 
     alias_method :script, :scripts
 
     def script_tag(src)
-      src = "#{src}.js" unless src =~ /\.js$/o
       %(<script type="text/javascript" src="#{src}"></script>)
     end
 
-    def convert_coffeescript(url)
-      S::Output::Assets.compile_coffeescript(url)
-    end
-
-    def compressed_scripts(scripts)
-      file_paths = scripts.map { |script| [script, S::Output::Assets.find_file("#{script}.js", "#{script}.coffee")] }
-      invalid, file_paths = file_paths.partition { |url, path| path.nil? }
-
-      tags = []
-      unless file_paths.empty?
-        # in order to compile coffeescript efficiently, avoiding multiple anonymous function wrappers
-        # but keeping the files in the correct order
-        # first partition files into js & coffee groups:
-        types = file_paths.slice_between { |(purl, ppath), (url, path)| File.extname(ppath) != File.extname(path) }
-        # then iterate through each group to concatenate the source into a single string (src)
-        js = types.map { |type|
-          ext = nil
-          src = type.map { |url, path|
-            ext = File.extname(path)
-            File.read(path)
-          }.join
-          # then compile the concatenated src if it's coffeescript
-          case ext
-          when ".coffee"
-            CoffeeScript.compile src
-          else
-            src
-          end
-        }.join
-
-        compressed, hash = compress_js_string(js)
-        output_path = Spontaneous::Output::Assets.path_for(revision, "#{hash}.js")
-
-        FileUtils.mkdir_p(File.dirname(output_path))
-        File.open(output_path, "w") { |file| file.write(compressed) }
-
-        tags = [script_tag(Spontaneous::Output::Assets.url(hash))]
-      end
-
-      tags.concat invalid.map { |src, path| script_tag(src) }
-      tags.join("\n")
-    end
-
-    def compress_js_string(js_string)
-      Spontaneous::Output::Assets::Compression.shine_compress_string(js_string, :js)
-    end
-
     Spontaneous::Output::Helpers.register_helper(self, :html)
   end
 end

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

@@ -7,55 +7,23 @@ module Spontaneous::Output::Helpers
     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_urls(*args).map { |stylesheet|
         stylesheet_tag(stylesheet)
-      end.join("\n")
+      }.join("\n")
+    end
+
+    def stylesheet_urls(*args)
+      options = args.extract_options!
+      options.update(:development => development?)
+      asset_environment.css(args.flatten, options)
     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/template/renderer.rb

@@ -18,24 +18,32 @@ module Spontaneous::Output::Template
 
     def render(output, params = {})
       output.model.with_visible do
-        engine.render(output.content, context(output, params), output.name.to_s)
+        engine.render(output.content, context(output, params), output.name)
       end
     end
 
     def render_string(template_string, output, params = {})
       output.model.with_visible do
-        engine.render_string(template_string, context(output, params), output.name.to_s)
+        engine.render_string(template_string, context(output, params), output.name)
       end
     end
 
     def context(output, params)
       context_class(output).new(output.content, params).tap do |context|
-        context.__renderer = self
+        context._renderer = renderer_for_context
       end
     end
 
+    def renderer_for_context
+      self
+    end
+
     def context_class(output)
-      context_cache[output.name] ||= generate_context_class(output)
+      if Spontaneous.development?
+        generate_context_class(output)
+      else
+        context_cache[output.name] ||= generate_context_class(output)
+      end
     end
 
     def context_cache
@@ -146,8 +154,12 @@ module Spontaneous::Output::Template
       request_renderer.render_string(rendered, output, params)
     end
 
+    def renderer_for_context
+      @renderer_for_context ||= PublishRenderer.new(@cache)
+    end
+
     def request_renderer
-      @request_renderer ||= RequestRenderer.new
+      @request_renderer ||= RequestRenderer.new(@cache)
     end
   end
 end

data/lib/spontaneous/output.rb

@@ -155,7 +155,6 @@ module Spontaneous
     autoload :Template, "spontaneous/output/template"
     autoload :Context,  "spontaneous/output/context"
     autoload :Helpers,  "spontaneous/output/helpers"
-    autoload :Assets,   "spontaneous/output/assets"
   end
 end
 

data/lib/spontaneous/paths.rb

@@ -4,17 +4,21 @@ require 'pathname'
 
 module Spontaneous
   class Paths < ::Hash
+    # TODO: Move this kind of stuff into the Revision class
+    # Instead of throwing around revision numbers we should
+    # be throwing around Revision instances. It is fecking OO
+    # after all...
     def self.pad_revision_number(revision)
       revision.to_s.rjust(5, "0")
     end
 
     def initialize(root)
       @root = File.expand_path(root)
-      super()
+      super() { |hash, key| hash[key] = [] }
     end
 
     def add(category, *paths)
-      self[category] = paths
+      self[category].concat(paths)
     end
 
     def expanded(category)

data/lib/spontaneous/permissions/access_key.rb

@@ -36,5 +36,23 @@ module Spontaneous::Permissions
     def access!(ip_address = nil)
       self.update(:last_access_at => Time.now, :last_access_ip => ip_address)
     end
+
+    CSFR_SEP = ":".freeze
+
+    def generate_csrf_token
+      salt = Spontaneous::Permissions.random_string(32)
+      [salt, generate_csrf_hash(salt)].join(CSFR_SEP)
+    end
+
+    def csrf_token_valid?(token)
+      return false if token.nil?
+      salt, fingerprint = token.split(CSFR_SEP)
+      generate_csrf_hash(salt) == fingerprint
+    end
+
+    def generate_csrf_hash(salt)
+      fingerprint = [salt, key_id].join(CSFR_SEP)
+      Spontaneous::Permissions.crypto_hash(fingerprint)
+    end
   end
 end

data/lib/spontaneous/permissions/user.rb

@@ -98,7 +98,7 @@ module Spontaneous::Permissions
     end
 
     def encrypt_password(clear_password)
-      Spontaneous::Crypt.hash(clear_password)
+      Spontaneous::Crypt.hash_password(clear_password)
     end
 
     def upgrade_authentication(auth)

data/lib/spontaneous/permissions.rb

@@ -1,6 +1,5 @@
 # encoding: UTF-8
 
-require 'base58'
 require 'securerandom'
 
 module Spontaneous
@@ -29,6 +28,10 @@ module Spontaneous
       def random_string(length)
         SecureRandom.urlsafe_base64(length)[0...(length)]
       end
+
+      def crypto_hash(string, algorithm = Digest::SHA1)
+        algorithm.new.update(string).hexdigest
+      end
     end
   end
 end

data/lib/spontaneous/plugins/application/state.rb

@@ -5,19 +5,26 @@ module Spontaneous::Plugins::Application
     extend Spontaneous::Concern
 
     module ClassMethods
+      @@semaphore = Mutex.new
+
       def init(options={})
-        # return false if loaded?
-        self.environment = (options.delete(:environment) || ENV["SPOT_ENV"] || :development)
-        self.mode = options.delete(:mode) || ENV["SPOT_MODE"] || :back
-        root = options.delete(:root) || ENV["SPOT_ROOT"] || Dir.pwd
-        site = Spontaneous::Site.instantiate(root, environment, mode)
-        lib = File.expand_path(File.join(root, "lib"))
-        $:.push(lib) unless $:.include?(lib)
-        Spontaneous::Logger.setup(:log_level => options[:log_level], :logfile => options[:logfile], :cli => options[:cli])
-        site.initialize!
-        site.schema.validate! if self.mode == :console
-        logger.warn "Auto login is enabled and set to '#{site.config.auto_login}'. Please ensure this is disabled in production mode by removing the 'auto_login' setting from your environment file." if site.config.auto_login and mode == :back
-        Thread.current[:spontaneous_loaded] = true
+        @@semaphore.synchronize do
+          self.environment = (options.delete(:environment) || ENV["SPOT_ENV"] || :development)
+          self.mode = options.delete(:mode) || ENV["SPOT_MODE"] || :back
+          root = options.delete(:root) || ENV["SPOT_ROOT"] || Dir.pwd
+          site = Spontaneous::Site.instantiate(root, environment, mode)
+          lib = File.expand_path(File.join(root, "lib"))
+          $:.push(lib) unless $:.include?(lib)
+          Spontaneous::Logger.setup(:log_level => options[:log_level], :logfile => options[:logfile], :cli => options[:cli])
+          site.initialize!
+          site.schema.validate! if self.mode == :console
+          if site.config.auto_login && mode == :back
+            logger.warn "Auto login is enabled and set to '#{site.config.auto_login}'.\n" \
+            "   Please ensure this is disabled in production mode by removing the\n" \
+            "   'auto_login' setting from your environment file."
+          end
+          Thread.current[:spontaneous_loaded] = true
+        end
       end
 
       # This is called after definition of the Content model.

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -10,13 +10,15 @@ module Spontaneous::Prototypes
       @name = name
       @extend = [blocks].flatten.push(block).compact
 
-      parse_options(options)
-
       # if the type is nil then try the name, this will assign sensible defaults
       # to fields like 'image' or 'date'
       @base_class = Spontaneous::Field[type || name]
 
-      owner.const_set("#{name.to_s.camelize}Field", instance_class)
+      parse_options(@base_class, options)
+
+
+      field_class_name = "#{name.to_s.camelize}Field"
+      owner.const_set(field_class_name, instance_class)
 
       self
     end
@@ -52,11 +54,12 @@ module Spontaneous::Prototypes
       @name.to_s.titleize
     end
 
-    def parse_options(options)
-      @options = {
-        :default => '',
-        :comment => false
-      }.merge(options)
+    def parse_options(field_class, options)
+      @options = default_options(field_class).merge(options)
+    end
+
+    def default_options(field_class)
+      {:default => '', :comment => false }.merge(field_class.default_options)
     end
 
     def instance_class
@@ -96,6 +99,9 @@ module Spontaneous::Prototypes
       @options[:comment]
     end
 
+    def fallback
+      @options[:fallback]
+    end
 
     # default read level is None, i.e. every logged in user can read the field
     def read_level

data/lib/spontaneous/published_revision.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class PublishedRevision < Sequel::Model(:revisions)
+
+  end
+end

data/lib/spontaneous/publishing/immediate.rb

@@ -87,15 +87,13 @@ module Spontaneous
           abort_publish_at_exit
         }
         before_publish
-        begin
-          @content_model.publish(revision, modified_page_list) do
-            render_revision
-          end
-          after_publish
-        rescue ::Exception => e
-          abort_publish(e)
-          raise(e)
+        @content_model.publish(revision, modified_page_list) do
+          render_revision
         end
+        after_publish
+      rescue ::Exception => e # Catch even interrupts because we definitely need to cleanup
+        abort_publish(e)
+        raise(e)
       end
 
       def render_revision
@@ -215,21 +213,25 @@ module Spontaneous
         public_dirs.each do |public_src|
           next unless public_src.exist?
           public_src = public_src.realpath
-          Dir[public_src.to_s / "**/*"].each do |src|
-            src = Pathname.new(src)
-            # insert facet namespace in front of path to keep URLs consistent across
-            # the back & front servers
-            dest = [facet.file_namespace, src.relative_path_from(public_src).to_s].compact
-            dest = (public_dest + File.join(dest))
-            if src.directory?
-              dest.mkpath
-            else
-              copy_public_file(src, dest)
-            end
+          Dir[public_src.to_s / "**/*"].each do |file|
+            copy_facet_public_dir(facet, file, public_src, public_dest)
           end
         end
       end
 
+      def copy_facet_public_dir(facet, original, public_src, public_dest)
+        original = Pathname.new(original)
+        # insert facet namespace in front of path to keep URLs consistent across
+        # the back & front servers
+        dest = File.join [facet.file_namespace, original.relative_path_from(public_src).to_s].compact
+        dest = public_dest + dest
+        if original.directory?
+          dest.mkpath
+        else
+          copy_public_file(original, dest)
+        end
+      end
+
       def copy_public_file(src, dest)
         # TODO: Add coffeescript compilation.
         # Should be implemented using sprockets
@@ -286,27 +288,34 @@ module Spontaneous
 
       def after_publish
         update_progress("finalising")
-        S::Revision.create(:revision => revision, :published_at => now)
-        Spontaneous::Site.send(:set_published_revision, revision)
-        tmp = Spontaneous.revision_dir(revision) / "tmp"
-        FileUtils.mkdir_p(tmp) unless ::File.exists?(tmp)
-        write_revision(revision)
-
         begin
-          Spontaneous::Site.trigger(:after_publish, revision)
-          Spontaneous::Site.send(:pending_revision=, nil)
-          Spontaneous::Content.cleanup_revisions(revision, keep_revisions)
+          tmp = Spontaneous.revision_dir(revision) / "tmp"
+          FileUtils.mkdir_p(tmp) unless ::File.exists?(tmp)
+          activate_revision
           update_progress("complete")
-        rescue Exception => e
+        rescue => e
           # if a post publish hook raises an exception then we want to roll everything back
-          S::Revision.filter(:revision => revision).delete
-          Spontaneous::Site.send(:set_published_revision, @previous_revision)
-          write_revision(@previous_revision)
-          abort_publish(e)
+          deactivate_revision
           raise e
         end
       end
 
+      def activate_revision
+        S::PublishedRevision.create(:revision => revision, :published_at => now)
+        Spontaneous::Site.send(:set_published_revision, revision)
+        write_revision(revision)
+        Spontaneous::Site.trigger(:after_publish, revision)
+        Spontaneous::Site.send(:pending_revision=, nil)
+        Spontaneous::Content.cleanup_revisions(revision, keep_revisions)
+      end
+
+      def deactivate_revision
+        S::PublishedRevision.filter(:revision => revision).delete
+        Spontaneous::Site.send(:set_published_revision, @previous_revision)
+        write_revision(@previous_revision)
+        abort_publish(e)
+      end
+
       # Makes the revision live on the filesystem by symlinking the revisions/current
       # directory to the revision directory and writing the current revision to the
       # revisions/REVISION file.
@@ -324,7 +333,7 @@ module Spontaneous
       end
 
       def abort_publish(exception)
-        if r = S::Site.pending_revision
+        if (r = S::Site.pending_revision)
           update_progress("aborting")
           FileUtils.rm_r(Spontaneous.revision_dir(revision)) if File.exists?(Spontaneous.revision_dir(revision))
           Spontaneous::Site.send(:pending_revision=, nil)

data/lib/spontaneous/publishing/revision.rb

@@ -28,7 +28,7 @@ module Spontaneous::Publishing
             yield if block_given?
           end
           set_source_timestamps
-        rescue ::Exception => e
+        rescue => e
           @revision.delete
           raise e
         end
@@ -157,11 +157,9 @@ module Spontaneous::Publishing
     end
 
     def self.delete_all(model)
-      revisions = tables(model).
-        map { |table| revision_from_table(model, table) }.
-        map { |r| new(model, r) }
+      revisions = tables(model).map { |table| for_table(model, table) }
 
-      # Don't call the full #delete because it is much more efficient
+      # Don't call the full Revision#delete because it is much more efficient
       # to delete the contents of the revision tables in a single
       # command rather than revision by revision
       revisions.each(&:delete_table)
@@ -191,6 +189,11 @@ module Spontaneous::Publishing
       ds.filter(:revision => revision, &block)
     end
 
+    def self.for_table(model, table)
+      r = revision_from_table(model, table)
+      new(model, r)
+    end
+
     def self.revision_from_table(model, table)
       model.mapper.revision_from_table(table)
     end
@@ -345,7 +348,7 @@ module Spontaneous::Publishing
     end
 
     def archive_dataset(&block)
-      _dataset(history_table, &block)
+      _dataset(archive_table, &block)
     end
 
     def _dataset(table, &block)