spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/rack/cacheable_file.rb

@@ -1,13 +1,13 @@
 
 module Spontaneous::Rack
   class CacheableFile < ::Rack::File
-    include HTTP
+    include Constants
 
     TEN_YEARS = 10*365.25*24*3600
     MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
 
     def initialize(file_root)
-      super(file_root, 'public')
+      super(file_root)
     end
 
     def call(env)
@@ -18,7 +18,7 @@ module Spontaneous::Rack
     # Send a far future Expires header and make sure that
     # the cache control is public
     def caching_headers(headers)
-      headers.merge({
+      headers.update({
         HTTP_CACHE_CONTROL => MAX_AGE,
         HTTP_EXPIRES => (Time.now.advance(:years => 10)).httpdate
       })

data/lib/spontaneous/rack/front.rb

@@ -5,32 +5,35 @@ require 'sinatra/base'
 module Spontaneous
   module Rack
     module Front
+      include Spontaneous::Rack::Middleware
+
+      def self.make_controller(controller_class)
+        ::Rack::Builder.app do
+          use Scope::Front
+          run controller_class
+        end
+      end
+
       def self.front_app
         ::Rack::Builder.app do
-          use AroundFront
-          use Reloader if Spontaneous::Site.config.reload_classes
+          use Scope::Front
+          use Reloader if Spontaneous.development?
           run Server.new
         end
       end
+
       def self.application
         app = ::Rack::Builder.new do
-          # use ::Rack::CommonLogger, STDERR  #unless server.name =~ /CGI/
-          # use ::Rack::ShowExceptions
-
-
           use Spontaneous::Rack::Static, :root => Spontaneous.revision_dir / "public",
             :urls => %w[/],
             :try => ['.html', 'index.html', '/index.html']
 
-
-
           Spontaneous.instance.front_controllers.each do |namespace, controller_class|
             map namespace do
               run controller_class
             end
           end if Spontaneous.instance
 
-
           # Make all the files available under plugin_name/public/**
           # available under the URL /plugin_name/**
           # Only used in preview mode
@@ -44,6 +47,10 @@ module Spontaneous
             run Spontaneous::Rack::CacheableFile.new(Spontaneous.revision_dir / "rev")
           end
 
+          map "/assets" do
+            run Spontaneous::Rack::CacheableFile.new(Spontaneous.revision_dir / "assets")
+          end
+
           map "/media" do
             run Spontaneous::Rack::CacheableFile.new(Spontaneous.media_dir)
           end

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

@@ -0,0 +1,65 @@
+require 'spontaneous/rack/back/base'
+require 'spontaneous/rack/back/helpers'
+
+module Spontaneous::Rack::Middleware
+  module Authenticate
+    class Init
+      include Spontaneous::Rack::Constants
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if (key = authenticate(env))
+          env[ACTIVE_KEY]  = key
+          env[ACTIVE_USER] = key.user
+        end
+        @app.call(env)
+      end
+
+      def authenticate(env)
+        remote_addr = env["REMOTE_ADDR"]
+        if (login = Spontaneous::Site.config.auto_login)
+          auto_login(login, remote_addr)
+        else
+          cookie_login(env, remote_addr)
+        end
+      end
+
+      def auto_login(login, remote_addr)
+        user = Spontaneous::Permissions::User.login(login)
+        if user.access_keys.empty?
+          user.generate_access_key(remote_addr)
+        else
+          user.access_keys.first
+        end
+      end
+
+      def cookie_login(env, remote_addr)
+        request = ::Rack::Request.new(env)
+        key_id  = request.cookies[AUTH_COOKIE]
+        return nil unless key_id
+        key = Spontaneous::Permissions::AccessKey.authenticate(key_id, remote_addr)
+        return nil unless key
+        key
+      end
+    end
+
+
+    class Edit < Spontaneous::Rack::Back::Base
+      include Spontaneous::Rack::Back::TemplateHelpers
+
+      before do
+        show_login_page unless user
+      end
+    end
+
+    class Preview < Spontaneous::Rack::Back::Base
+      before do
+        redirect NAMESPACE, 302 unless user
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,66 @@
+module Spontaneous::Rack::Middleware
+  module CSRF
+    # Creates and inserts CSRF tokens into Rack env
+    # If token is present then it validates it and adds the validation
+    # status to the `env`. If it isn't present then one is created
+    # passed into the `env` and the validation flag is unset
+    #
+    # This depends on the presences of an AccessKey in the `env`
+    class Header
+      include Spontaneous::Rack::Constants
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if (key = env[ACTIVE_KEY])
+          token = load_token(env)
+          call!(env, key, token)
+        else
+          # Should never happen as authentication should be enforced further up
+          # the stack
+          [401, {}, ["Unauthorised"]]
+        end
+      end
+
+      def load_token(env)
+        header_token(env) || param_token(env)
+      end
+
+      def header_token(env)
+        env[CSRF_ENV]
+      end
+
+      def param_token(env)
+        request = ::Rack::Request.new(env)
+        request.params[CSRF_PARAM]
+      end
+
+      def call!(env, key, token)
+        valid = valid?(key, token)
+        token ||= key.generate_csrf_token
+        @app.call(env.merge(CSRF_VALID => valid, CSRF_TOKEN => token))
+      end
+
+      def valid?(key, token)
+        key.csrf_token_valid?(token)
+      end
+    end
+
+    # Provides CSRF verification for requests. Relies upon the Header
+    # app to insert the validation step.
+    class Verification
+      include Spontaneous::Rack::Constants
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return [401, {}, ["Unauthorised"]] unless env[CSRF_VALID]
+        @app.call(env)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require 'stringio'
+require 'erubis'
+require 'tilt'
+
+require 'spontaneous/rack/back/helpers'
+
+module Spontaneous::Rack::Middleware
+  class Reloader
+    include Spontaneous::Rack::Back::TemplateHelpers
+
+    def initialize(app, *args)
+      @app      = app
+      @active   = Spontaneous::Site.config.reload_classes
+      config    = args.first || {}
+      @cooldown = config[:cooldown] || 3
+      @last     = (Time.now - @cooldown)
+    end
+
+    def call(env)
+      reload if should_reload?
+      @app.call(env)
+    rescue Spontaneous::SchemaModificationError => error
+      schema_conflict!(env, error)
+    end
+
+    def should_reload?
+      @active && @cooldown && (Time.now > (@last + @cooldown))
+    end
+
+    def reload
+      if Thread.list.size > 1
+        Thread.exclusive{ reload! }
+      else
+        reload!
+      end
+      @last = Time.now
+    end
+
+    def reload!
+      Spontaneous.reload!
+    end
+
+    def schema_conflict!(env, error)
+      template_path = ::File.expand_path('../../../../../application/views/schema_modification_error.html.erb', __FILE__)
+      template = Tilt::ErubisTemplate.new(template_path)
+      html = template.render(self, :modification => error.modification, :env => env)
+      [412, {'Content-type' => ::Rack::Mime.mime_type('.html')}, StringIO.new(html)]
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Spontaneous::Rack::Middleware
+  module Scope
+    class Edit
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        response = nil
+        Spontaneous::Content.scope(nil, false) do
+          response = @app.call(env)
+        end
+        response
+      end
+    end
+
+    class Preview
+      include Spontaneous::Rack::Constants
+
+      def initialize(app)
+        @app = app
+        @renderer = Spontaneous::Output.preview_renderer
+        Spontaneous::Output.renderer = @renderer
+      end
+
+      def call(env)
+        env[RENDERER] = @renderer
+        response = nil
+        Spontaneous::Content.scope(nil, true) do
+          response = @app.call(env)
+        end
+        response
+      end
+    end
+
+    POWERED_BY = {
+      "X-Powered-By" => "Spontaneous CMS v#{Spontaneous::VERSION}"
+    }
+
+    class Front
+      include Spontaneous::Rack::Constants
+
+      def initialize(app)
+        @app = app
+        @renderer = Spontaneous::Output.published_renderer
+      end
+
+      def call(env)
+        status = headers = body = nil
+        env[RENDERER] = @renderer
+        env[REVISION] = Spontaneous::Site.published_revision
+        Spontaneous::Content.with_published do
+          status, headers, body = @app.call(env)
+        end
+        [status, headers.merge(POWERED_BY), body]
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/middleware.rb

@@ -0,0 +1,6 @@
+module Spontaneous::Rack::Middleware
+  autoload :Authenticate, "spontaneous/rack/middleware/authenticate"
+  autoload :CSRF,         "spontaneous/rack/middleware/csrf"
+  autoload :Reloader,     "spontaneous/rack/middleware/reloader"
+  autoload :Scope,        "spontaneous/rack/middleware/scope"
+end

data/lib/spontaneous/rack/page_controller.rb

@@ -4,15 +4,28 @@ require 'sinatra/base'
 
 module Spontaneous::Rack
   class PageController < Sinatra::Base
-    attr_reader :content, :format
+    include Spontaneous::Rack::Public
+    attr_reader :content, :page, :output
 
-    def initialize(content, format)
-      @content, @format = content, (format || :html).to_sym
+    def initialize(content, output)
+      @content, @output = content, (output || :html).to_sym
+      @page = content.page
       super(nil)
     end
 
-    def page
-      content.page
+    def render(*args)
+      params = args.extract_options!
+      output = @output
+      page   = @page
+      args.each do |arg|
+        case arg
+        when Symbol
+          output = arg
+        when Spontaneous::Content
+          page = arg
+        end
+      end
+      _render_page_with_output(page, output, params)
     end
   end
 end

data/lib/spontaneous/rack/public.rb

@@ -4,11 +4,9 @@
 module Spontaneous
   module Rack
     module Public
-      include HTTP
+      include Constants
       include Sinatra::Helpers unless method_defined?(:redirect)
 
-
-
       attr_reader :env, :response, :request
       attr_accessor :page
 
@@ -129,11 +127,15 @@ module Spontaneous
 
       def find_page!(path)
         @path, @output, @action = parse_path(path)
-        @page = Spontaneous::Site[@path]
+        @page = find_page_by_path(@path)
+      end
+
+      def find_page_by_path(path)
+        Spontaneous::Site.by_path(path)
       end
 
-      def output
-        @output
+      def output(name)
+        @output = name.to_s
       end
 
       def action
@@ -164,7 +166,7 @@ module Spontaneous
       end
 
       def call_action!
-        status, headers, result = @page.process_action(action, request.env, output)
+        status, headers, result = @page.process_action(action, request.env, @output)
         if status == 404
           not_found!
         else
@@ -189,14 +191,18 @@ module Spontaneous
       end
 
       def render_page_with_output
-        return not_found! if     @page.nil?
-        return not_found! unless @page.provides_output?(@output)
+        _render_page_with_output(@page, @output, @template_params)
+      end
+
+      def _render_page_with_output(page, output, template_params)
+        return not_found! if     page.nil?
+        return not_found! unless page.provides_output?(output)
 
-        output = @page.output(@output)
+        output = page.output(output)
 
         if output.public?
           content_type(output.mime_type)
-          render_page(@page, output, @template_params)
+          render_page(page, output, template_params)
         else
           not_found!
         end

data/lib/spontaneous/rack.rb

@@ -5,14 +5,35 @@ require "sinatra/base"
 
 module Spontaneous
   module Rack
-    NAMESPACE   = "/@spontaneous".freeze
-    ACTIVE_USER = "SPONTANEOUS_USER".freeze
-    ACTIVE_KEY  = "SPONTANEOUS_KEY".freeze
-    AUTH_COOKIE = "spontaneous_api_key".freeze
-    KEY_PARAM   = "__key".freeze
-    RENDERER    = "spot.renderer".freeze
+    module Constants
+      METHOD_GET = "GET".freeze
+      METHOD_POST = "POST".freeze
+      METHOD_HEAD = "HEAD".freeze
+      HTTP_CONTENT_LENGTH = "Content-Length".freeze
+      HTTP_EXPIRES = "Expires".freeze
+      HTTP_CACHE_CONTROL = "Cache-Control".freeze
+      HTTP_LAST_MODIFIED = "Last-Modified".freeze
+      HTTP_NO_CACHE = "max-age=0, must-revalidate, no-cache, no-store".freeze
 
-    EXPIRES_MAX = DateTime.parse("Thu, 31 Dec 2037 23:55:55 GMT").httpdate
+      NAMESPACE      = "/@spontaneous".freeze
+      AUTH_COOKIE    = "spontaneous_api_key".freeze
+      SESSION_LIFETIME = 1.year
+      # Rack env params
+      ACTIVE_USER    = "spot.user".freeze
+      ACTIVE_KEY     = "spot.key".freeze
+      RENDERER       = "spot.renderer".freeze
+      REVISION       = "spot.revision".freeze
+      CSRF_VALID     = "spot.csrf_valid".freeze
+      CSRF_TOKEN     = "spot.csrf_token".freeze
+
+      CSRF_HEADER    = "X-CSRF-Token".freeze
+      CSRF_PARAM     = "__token".freeze
+      CSRF_ENV       = ("HTTP_" << CSRF_HEADER.upcase.gsub(/-/, "_")).freeze
+
+      EXPIRES_MAX = DateTime.parse("Thu, 31 Dec 2037 23:55:55 GMT").httpdate
+    end
+
+    include Constants
 
     class << self
       def application
@@ -29,43 +50,32 @@ module Spontaneous
       end
 
       def make_front_controller(controller_class)
-        controller_class.use(Spontaneous::Rack::AroundFront)
+        Spontaneous::Rack::Front.make_controller(controller_class)
       end
 
       def make_back_controller(controller_class)
-        controller_class.helpers Spontaneous::Rack::Helpers
-        controller_class.helpers Spontaneous::Rack::UserHelpers
-        controller_class.use Spontaneous::Rack::CookieAuthentication
-        controller_class.use Spontaneous::Rack::AroundBack
-        controller_class.register Spontaneous::Rack::Authentication
+        Spontaneous::Rack::Back.make_controller(controller_class)
       end
     end
 
     class ServerBase < ::Sinatra::Base
+      include Constants
+
       set :environment, Proc.new { Spontaneous.environment }
     end
 
-    autoload :AroundBack,           'spontaneous/rack/around_back'
-    autoload :AroundFront,          'spontaneous/rack/around_front'
-    autoload :AroundPreview,        'spontaneous/rack/around_preview'
     autoload :Assets,               'spontaneous/rack/assets'
-    autoload :Authentication,       'spontaneous/rack/authentication'
+    autoload :AssetServer,          'spontaneous/rack/asset_server'
     autoload :Back,                 'spontaneous/rack/back'
     autoload :CSS,                  'spontaneous/rack/css'
     autoload :CacheableFile,        'spontaneous/rack/cacheable_file'
-    autoload :CookieAuthentication, 'spontaneous/rack/cookie_authentication'
     autoload :EventSource,          'spontaneous/rack/event_source'
     autoload :Front,                'spontaneous/rack/front'
-    autoload :HTTP,                 'spontaneous/rack/http'
-    autoload :Helpers,              'spontaneous/rack/helpers'
     autoload :JS,                   'spontaneous/rack/js'
+    autoload :Middleware,           'spontaneous/rack/middleware'
     autoload :PageController,       "spontaneous/rack/page_controller"
     autoload :Public,               'spontaneous/rack/public'
-    autoload :QueryAuthentication,  'spontaneous/rack/query_authentication'
-    autoload :Reloader,             'spontaneous/rack/reloader'
     autoload :SSE,                  'spontaneous/rack/sse'
     autoload :Static,               'spontaneous/rack/static'
-    autoload :UserAdmin,            'spontaneous/rack/user_admin'
-    autoload :UserHelpers,          'spontaneous/rack/user_helpers'
   end
 end

data/lib/spontaneous/revision.rb

@@ -1,7 +1,34 @@
-# encoding: UTF-8
+require 'pathname'
 
 module Spontaneous
-  class Revision < Sequel::Model(:revisions)
+  class Revision
+    attr_reader :revision
 
+    def initialize(revision)
+      @revision = revision.to_i
+    end
+
+    def root
+      ::File.join(Spontaneous::Site.instance.revision_root, padded_revision)
+    end
+
+    def path(*path)
+      path = path.flatten
+      Pathname.new(File.join(root, *path.map(&:to_s)))
+    end
+
+    def padded_revision
+      Spontaneous::Paths.pad_revision_number(revision)
+    end
+
+    def to_i
+      @revision
+    end
+
+    module GlobalMethods
+      def revision(revision)
+        Revision.new(revision)
+      end
+    end
   end
 end

data/lib/spontaneous/schema/uid.rb

@@ -1,8 +1,5 @@
 # encoding: UTF-8
 
-
-require 'base58'
-
 module Spontaneous
   module Schema
     class UID
@@ -132,6 +129,10 @@ module Spontaneous
         self.to_s <=> other.to_s
       end
 
+      def to_json(options = {})
+        to_s.to_json(options)
+      end
+
       def inspect
         %(#<#{self.class}:"#{@id}" => "#{reference}">)
       end

data/lib/spontaneous/schema/uid_map.rb

@@ -1,8 +1,5 @@
 # encoding: UTF-8
 
-
-require 'base58'
-
 module Spontaneous::Schema
   class UIDMap
 
@@ -10,36 +7,20 @@ module Spontaneous::Schema
       @uid_lock ||= Mutex.new
     end
 
-    def self.uid_index
-      @uid_index ||= 0
-    end
-
-    def self.increment_uid_index
-      @uid_index = (uid_index + 1) % 0xFFFF
-    end
-
     def self.get_inc
       uid_lock.synchronize do
-        increment_uid_index
+        @uid_index = ((@uid_index ||= 0) + 1) % 0xFFFF
       end
     end
 
     def self.generate(ref = nil)
-      generate58(ref)
+      generate36(ref)
     end
 
-    def self.generate58(ref)
+    def self.generate36(ref)
       # reverse the time so that sequential ids are more obviously different
-      oid =  Base58.encode((Time.now.to_f * 1000).to_i).reverse
-      oid << Base58.encode(get_inc).rjust(3, '0')
-    end
-
-    def self.generate16(ref)
-      oid = ''
-      # 4 bytes current time
-      oid = (Time.now.to_f * 1000).to_i.to_s(16)
-      # 2 bytes inc
-      oid << get_inc.to_s(16).rjust(4, '0')
+      oid =  (Time.now.to_f * 1000).to_i.to_s(36).reverse
+      oid << get_inc.to_s(36).rjust(3, '0')
     end
 
     include Enumerable

data/lib/spontaneous/schema.rb

@@ -340,6 +340,7 @@ module Spontaneous
       end
 
       def constants_of(klass)
+        return [] unless klass.respond_to?(:constants)
         klass.constants.
           select { |c| klass.const_defined?(c, false) }.
           map { |c| klass.const_get(c) }

data/lib/spontaneous/search/database.rb

@@ -46,6 +46,14 @@ module Spontaneous::Search
       @database ||= open_database
     end
 
+    def stemmer
+      @index.stemmer
+    end
+
+    def stopper
+      @index.stopper
+    end
+
     def open_database
       XapianFu::XapianDb.new(xapian_options)
     end

data/lib/spontaneous/search/field.rb

@@ -88,7 +88,7 @@ module Spontaneous::Search
 
     def find_index(name)
       index = S::Site.indexes[name]
-      logger.warn("Invalid index :#{opts} for field #{@prototype.owner}.#{@prototype.name}") unless index
+      logger.warn("Invalid index :#{name} for field #{@prototype.owner}.#{@prototype.name}") unless index
       index
     end
   end