spontaneous 0.2.0.beta9 → 0.2.0.beta10

data/lib/spontaneous/publishing/steps.rb

@@ -22,9 +22,11 @@ module Spontaneous::Publishing
       end
     end
 
-    def self.rerender
-      new do
-        run :render_revision
+    def self.rerender(publishing_steps)
+      new([], publishing_steps.progress) do
+        RERENDER_STEPS.each do |step|
+          run step
+        end
       end
     end
 
@@ -140,6 +142,13 @@ module Spontaneous::Publishing
       :archive_old_revisions
     ].freeze
 
+    RERENDER_STEPS = [
+      :render_revision,
+      :copy_assets,
+      :copy_static_files,
+      :generate_rackup_file
+    ].freeze
+
     CORE_PROGRESS = [:browser, :stdout].freeze
   end
 end

data/lib/spontaneous/rack.rb

@@ -15,6 +15,8 @@ module Spontaneous
       HTTP_LAST_MODIFIED = "Last-Modified".freeze
       HTTP_NO_CACHE = "max-age=0, must-revalidate, no-cache, no-store".freeze
 
+      SLASH = Spontaneous::Constants::SLASH
+
       NAMESPACE      = "/@spontaneous".freeze
       AUTH_COOKIE    = "spontaneous_api_key".freeze
       SESSION_LIFETIME = 1.year

data/lib/spontaneous/rack/asset_server.rb

@@ -3,6 +3,8 @@ module Spontaneous::Rack
   # header. This wrapper class proxies all requests to a Sprockets enviroment
   # and adds in a charset setting to the content-type header of all responses
   class AssetServer
+    CONTENT_TYPE = "Content-Type".freeze
+
     def initialize(environment, charset = "UTF-8")
       @environment, @charset = environment, charset
     end
@@ -12,8 +14,9 @@ module Spontaneous::Rack
     end
 
     def force_encoding(status, headers, body)
-      content_type = headers["Content-Type"]
-      headers.update("Content-Type" => "#{content_type}; charset=#{@charset}")
+      if (content_type = headers[CONTENT_TYPE])
+        headers.update(CONTENT_TYPE => "#{content_type}; charset=#{@charset}")
+      end
       [status, headers, body]
     end
   end

data/lib/spontaneous/rack/back.rb

@@ -18,6 +18,7 @@ module Spontaneous
       autoload :Map,                'spontaneous/rack/back/map'
       autoload :Page,               'spontaneous/rack/back/page'
       autoload :Preview,            'spontaneous/rack/back/preview'
+      autoload :Private,            'spontaneous/rack/back/private'
       autoload :Schema,             'spontaneous/rack/back/schema'
       autoload :Site,               'spontaneous/rack/back/site'
       autoload :SiteAssets,         'spontaneous/rack/back/site_assets'
@@ -48,6 +49,7 @@ module Spontaneous
 
       def self.editing_app(site)
         ::Rack::Builder.app do
+          use ::Rack::ShowExceptions if site.development?
           use Scope::Edit, site
           use Transaction, site
           use ApplicationAssets
@@ -62,6 +64,10 @@ module Spontaneous
           map("/schema")  { run Schema }
           use Reloader, site
           use Index
+          map("/private") {
+            use Scope::Preview, site
+            run Private
+          }
           use CSRF::Verification # Everything after this middleware requires a valid CSRF token
           Back.api_handlers.each do |path, app|
             map(path) { run app }
@@ -73,6 +79,7 @@ module Spontaneous
 
       def self.preview_app(site)
         ::Rack::Builder.app do
+          use ::Rack::ShowExceptions if site.development?
           use ::Rack::Lint if Spontaneous.development?
           use Scope::Preview, site
           use Transaction, site
@@ -84,7 +91,6 @@ module Spontaneous
           # the preview site.
           use Authenticate::Preview
           use CSRF::Header
-          map("/assets") { run SiteAssets.new }
           use Spontaneous::Rack::Static, root: Spontaneous.root / "public", urls: %w[/], try: ['.html', 'index.html', '/index.html']
           use Reloader, site
           # inject the front controllers into the preview so that this is a
@@ -128,6 +134,8 @@ module Spontaneous
             end
           end if site
 
+          map("/assets") { run SiteAssets.new }
+
           map "/media" do
             use ::Rack::Lint
             run Spontaneous::Rack::CacheableFile.new(Spontaneous.media_dir)

data/lib/spontaneous/rack/back/base.rb

@@ -4,6 +4,7 @@ module Spontaneous::Rack
       helpers  Helpers
 
       set :views, Proc.new { Spontaneous.application_dir + '/views' }
+      set :show_exceptions, false
 
       def content_model
         site.model

data/lib/spontaneous/rack/back/changes.rb

@@ -15,5 +15,10 @@ module Spontaneous::Rack::Back
       site.publish_pages(pages)
       json({})
     end
+
+    post '/rerender' do
+      site.rerender
+      json({})
+    end
   end
 end

data/lib/spontaneous/rack/back/preview.rb

@@ -2,12 +2,12 @@ module Spontaneous::Rack::Back
   class Preview < Base
     include Spontaneous::Rack::Public
 
+    set :show_exceptions, proc { Spontaneous.development? || Spontaneous.test? }
+
     # In preview mode we want to find pages even if they're
     # invisible.
-    def find_page_by_path(path)
-      site.model.scope do
-        site.by_path(path)
-      end
+    def with_scope(&block)
+      site.model.scope(&block)
     end
 
     # Redirect to the edit UI if a preview page is being accessed directly

data/lib/spontaneous/rack/back/private.rb

@@ -0,0 +1,11 @@
+module Spontaneous::Rack::Back
+  class Private < Base
+    include Spontaneous::Rack::Public
+
+    get '/:id.?:format?' do
+      content_for_request { |page|
+        _render_page_with_output(page, "html", {})
+      }
+    end
+  end
+end

data/lib/spontaneous/rack/middleware/scope.rb

@@ -41,7 +41,7 @@ module Spontaneous::Rack::Middleware
     end
 
     POWERED_BY = {
-      "X-Powered-By" => "Spontaneous CMS v#{Spontaneous::VERSION}"
+      "X-Powered-By" => "Spontaneous v#{Spontaneous::VERSION} <http://spontaneous.io>"
     }
 
     class Front < Base
@@ -49,18 +49,30 @@ module Spontaneous::Rack::Middleware
 
       def initialize(app, site, options = {})
         super
-        @renderer = Spontaneous::Output.published_renderer(@site)
       end
 
       def call!(env)
         status = headers = body = nil
-        env[RENDERER] = @renderer
-        env[REVISION] = @site.published_revision
+        env[RENDERER] = renderer
+        env[REVISION] = revision = @site.published_revision
         @site.model.with_published(@site) do
           status, headers, body = @app.call(env)
         end
         [status, headers.merge(POWERED_BY), body]
       end
+
+      def renderer
+        return renderer_for_revision if development?
+        @renderer ||= renderer_for_revision
+      end
+
+      def renderer_for_revision
+        Spontaneous::Output.published_renderer(@site)
+      end
+
+      def development?
+        Spontaneous.development?
+      end
     end
   end
 end

data/lib/spontaneous/rack/page_controller.rb

@@ -6,7 +6,7 @@ module Spontaneous::Rack
   class PageController < Sinatra::Base
     class << self
       # We wrap Sinatra's route methods in order to do two things:
-      #   1. To provide a path of '/' when none is given and
+      #   1. To provide a path of '*' when none is given and
       #   2. To register the presence of a handler for each method in order to
       #      correctly respond to the #dynamic? test
       def get(*args, &bk)     __dynamic!(:get,     super(*__route_args(args), &bk)) end
@@ -28,7 +28,7 @@ module Spontaneous::Rack
 
       def __route_args(args)
         opts = args.extract_options!
-        path = String === args.first ? args.first : '/'
+        path = (String === args.first) ? args.first : S::Constants::SLASH
         [path, opts]
       end
 

data/lib/spontaneous/rack/public.rb

@@ -87,12 +87,52 @@ module Spontaneous
       end
 
       def find_page!(path)
+        @controller_path = SLASH
         @path, @output, @action = parse_path(path)
         @page = find_page_by_path(@path)
       end
 
       def find_page_by_path(path)
-        site.by_path(path)
+        with_scope { site.by_path(path)  || find_page_with_wildcards(path) }
+      end
+
+      # if we get to here it's because the path hasn't been found. This will get called for
+      # every request where the request doesn’t resolve to a path found in the db
+      # and will always try the site homepage as a last resort. So if you need many dynamic
+      # routes to resolve to a single page, e.g. for a single page app, then you just
+      # need to accept all those routes in a controller on the class of the site’s homepage
+      # and render your SPA template from that, e.g.
+      #
+      #     class Homepage < Page
+      #       controller do
+      #         get '/app*' do
+      #           render
+      #         end
+      #       end
+      #     end
+      #
+      def find_page_with_wildcards(path)
+        parts = path.split('/')
+        length = parts.length - 2
+        range = (1..length).to_a.reverse
+
+        # make sure we go all the way back to the site homepage
+        try = range.map { |l| parts[0..l].join(SLASH) }.push(SLASH)
+        candidate = site.model::Page.where(path: try).order(Sequel.desc(:depth)).first
+        return nil if candidate.nil? || !candidate.dynamic?(request.request_method)
+
+        # don't pass the full path of the request to the controller, just
+        # the bit after the candidate page’s path.
+        cpath = candidate.path
+        @controller_path = path.slice(cpath.length, path.length - cpath.length)
+
+        # special handling of root, as always so that a controller on the root page that
+        # matches '/', e.g. `get '/'` is passed a path that starts with '/'
+        if cpath == SLASH
+          @controller_path.insert(0, SLASH)
+        end
+
+        candidate
       end
 
       def output(name)
@@ -106,7 +146,7 @@ module Spontaneous
       def render_get
         return call_action! if @action
         if page.dynamic?(request.request_method)
-          invoke_action { page.process_root_action(site, env.dup, @output) }
+          invoke_action { page.process_root_action(site, env_for_action, @output) }
         else
           render_page_with_output
         end
@@ -119,11 +159,15 @@ module Spontaneous
 
         return call_action! if @action
 
-        invoke_action { page.process_root_action(site, env.dup, @output) }
+        invoke_action { page.process_root_action(site, env_for_action, @output) }
       end
 
       def call_action!
-        invoke_action { @page.process_action(site, action, env.dup, @output) }
+        invoke_action { @page.process_action(site, action, env_for_action, @output) }
+      end
+
+      def env_for_action
+        env.merge(S::Constants::PATH_INFO => @controller_path)
       end
 
       def invoke_action
@@ -185,6 +229,10 @@ module Spontaneous
       def not_found!
         404
       end
+
+      def with_scope
+        yield
+      end
     end
   end
 end

data/lib/spontaneous/sequel.rb

@@ -2,16 +2,13 @@ require "sequel"
 
 Sequel.extension :inflector
 
-require 'sequel/plugins/serialization'
-
-Sequel::Plugins::Serialization.register_format(
-  :ojson,
-  lambda { |v| Yajl::Encoder.new.encode(v) },
-  lambda { |v| Yajl::Parser.new(:symbolize_keys => true).parse(v)   }
-)
-# Sequel::Plugins::Serialization.register_format(
-#   :ojson,
-#   lambda { |v| Oj.dump(v) },
-#   lambda { |v| Oj.load(v, symbol_keys: true)   }
-# )
-
+# See http://sequel.jeremyevans.net/rdoc/classes/Sequel/Timezones.html
+# UTC is more performant than :local (or 'nil' which just fallsback to :local)
+# A basic profiling run gives a 2 x performance improvement of :utc over :local
+# With ~240 rows, timing ::Content.all gives:
+#
+#     :utc     ~0.04s
+#     :local   ~0.08s
+#
+# DB timestamps are only shown in the editing UI & could be localized there per-user
+Sequel.default_timezone = :utc

data/lib/spontaneous/site.rb

@@ -84,19 +84,31 @@ module Spontaneous
 
 
     def connect_to_database!
-      db = Sequel.connect(db_settings)
-      db.logger = logger if config.log_queries
-      # Improve performance for postgres
-      db.optimize_model_load = true if db.respond_to?(:optimize_model_load)
-      self.database = db
+      self.database = database_instance(db_settings).tap do |db|
+        db.logger = logger if config.log_queries
+        # Improve performance for postgres
+        db.optimize_model_load = true if db.respond_to?(:optimize_model_load)
+      end
+    end
+
+    def database_instance(opts)
+      Sequel.connect(opts)
     end
 
     def db_settings
-      self.config.db = db_config[environment]
+      self.config.db ||= db_connection_options(environment)
     end
 
-    def db_config
-      @db_config ||= YAML.load_file(File.join(paths.expanded(:config).first, "database.yml"))
+    def db_connection_options(env)
+      (db_config_env || db_config_file[env])
+    end
+
+    def db_config_env
+      ENV['DATABASE_URL']
+    end
+
+    def db_config_file
+      YAML.load_file(File.join(paths.expanded(:config).first, "database.yml"))
     end
 
     def transaction(&block)
@@ -161,5 +173,13 @@ module Spontaneous
       return cache_root if path.empty?
       File.join(cache_root, *path)
     end
+
+    def development?
+      Spontaneous.development?
+    end
+
+    def inspect
+      %[#<Site @root="#@root" @schema=#{@schema.inspect} @paths=#{@paths.inspect} @environment=#{@environment.inspect} @mode=#{@mode.inspect}>]
+    end
   end
 end

data/lib/spontaneous/site/publishing.rb

@@ -43,7 +43,7 @@ class Spontaneous::Site
     end
 
     def rerender_steps
-      Spontaneous::Publishing::Steps.rerender
+      Spontaneous::Publishing::Steps.rerender(publish_steps)
     end
 
     def publishing_method

data/lib/spontaneous/site/storage.rb

@@ -20,8 +20,11 @@ class Spontaneous::Site
   module Storage
     extend Spontaneous::Concern
 
-    def storage(mimetype = nil)
-      storage_for_mimetype(mimetype)
+    DEFAULT_STORAGE_NAME = 'default'.freeze
+
+    def storage(name = nil)
+      return storage_backends.first if name.nil?
+      storage_backends.detect { |storage| storage.name == name } || default_storage
     end
 
     def storage_for_mimetype(mimetype)
@@ -40,14 +43,14 @@ class Spontaneous::Site
       storage_backends = []
       storage_settings = config[:storage] || []
       storage_settings.each do |name, config|
-        backend = Spontaneous::Media::Store.create(config)
+        backend = Spontaneous::Media::Store.create(name.to_s, config)
         storage_backends << backend
       end
       storage_backends << default_storage
     end
 
     def default_storage
-      @default_storage ||= Spontaneous::Media::Store::Local.new(Spontaneous.media_dir, '/media', accepts=nil)
+      @default_storage ||= Spontaneous::Media::Store::Local.new(DEFAULT_STORAGE_NAME, Spontaneous.media_dir, '/media', accepts=nil)
     end
 
     def file(owner, filename, headers = {})

data/lib/spontaneous/tasks/environment.rake

@@ -0,0 +1,3 @@
+
+task :environment do
+end

data/lib/spontaneous/utils/database/postgres_dumper.rb

@@ -18,7 +18,8 @@ module Spontaneous
           options = [
             "psql",
             "--quiet",
-            option(:password),
+            option(:host),
+            option(:port),
             option(:username),
             database_name
           ]
@@ -42,7 +43,8 @@ module Spontaneous
             "--clean",
             "--no-owner",
             "--no-privileges",
-            option(:password),
+            option(:host),
+            option(:port),
             option(:username),
             option(:encoding),
             option(:exclude_table),
@@ -69,6 +71,14 @@ module Spontaneous
           @database.opts[:password]
         end
 
+        def host
+          @database.opts[:host]
+        end
+
+        def port
+          @database.opts[:port]
+        end
+
         def encoding
           "UTF8"
         end
@@ -76,6 +86,17 @@ module Spontaneous
         def exclude_table
           revision_archive_table
         end
+
+        def system(cmd)
+          begin
+            if (pass = password)
+              ENV['PGPASSWORD'] = pass
+            end
+            super
+          ensure
+            ENV.delete('PGPASSWORD')
+          end
+        end
       end
     end
   end