spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/rack/back.rb

@@ -1,7 +1,8 @@
 # encoding: UTF-8
 
 require 'sass'
-require 'less'
+require 'sinatra/streaming'
+require 'sprockets'
 
 module Spontaneous
   module Rack
@@ -19,6 +20,54 @@ module Spontaneous
         @messenger
       end
 
+      class EventSource < ServerBase
+        helpers Sinatra::Streaming
+
+        get "/", :provides => "text/event-stream" do
+          headers "X-Accel-Buffering" =>  "no"
+          stream(:keep_open) do |out|
+            messenger = Spontaneous::Rack::Back.messenger
+            out.errback  { messenger.delete(out) }
+            out.callback { messenger.delete(out) }
+            messenger << out
+          end
+        end
+      end
+
+      def self.editing_app
+        ::Rack::Builder.app do
+          use Spontaneous::Rack::FiberPool, :size => 15
+          use ::Rack::Lint
+          use Spontaneous::Rack::Static, :root => Spontaneous.application_dir, :urls => %W(/static)
+          use Spontaneous::Rack::Static, :root => Spontaneous.root / "public/@spontaneous", :urls => %W(/assets)
+          use AssetsHandler
+          use UnsupportedBrowserHandler
+          use SchemaModification
+          map "/users" do
+            run UserAdmin
+          end
+          run EditingInterface
+        end
+      end
+
+      def self.preview_app
+        ::Rack::Builder.app do
+          use ::Rack::Lint
+          use Spontaneous::Rack::Static, :root => Spontaneous.root / "public",
+            :urls => %w[/],
+            :try => ['.html', 'index.html', '/index.html']
+          use Spontaneous::Rack::CSS, :root => Spontaneous.instance.paths.expanded(:public)
+          use Spontaneous::Rack::JS,  :root => Spontaneous.instance.paths.expanded(:public)
+          run Preview
+        end
+      end
+
+      def self.assets_app(dir)
+        ::Sprockets::Environment.new(Spontaneous.application_dir) do |environment|
+          environment.append_path("#{dir}")
+        end
+      end
+
       def self.application
         messenger = self.messenger
         app = ::Rack::Builder.new do
@@ -45,9 +94,6 @@ module Spontaneous
           # Needs testing...
           # ###################
 
-          use Spontaneous::Rack::Static, :root => Spontaneous.root / "public",
-            :urls => %w[/],
-            :try => ['.html', 'index.html', '/index.html']
 
           ################### REMOVE THIS
           # map "#{NAMESPACE}/lock" do
@@ -84,16 +130,23 @@ module Spontaneous
           map "#{NAMESPACE}/events" do
             use CookieAuthentication
             use QueryAuthentication
-            run messenger.app
+            run EventSource
+          end
+
+          map "#{NAMESPACE}/event" do
+            run EventListener
+          end
+
+          map "#{NAMESPACE}/css" do
+            run Spontaneous::Rack::Back.assets_app("css")
+          end
+
+          map "#{NAMESPACE}/js" do
+            run Spontaneous::Rack::Back.assets_app("js")
           end
 
           map NAMESPACE do
-            use ::Rack::Lint
-            use Spontaneous::Rack::Static, :root => Spontaneous.application_dir, :urls => %W(/static /js)
-            use AssetsHandler
-            use UnsupportedBrowserHandler
-            use SchemaModification
-            run EditingInterface
+            run Spontaneous::Rack::Back.editing_app
           end
 
           map "/media" do
@@ -102,13 +155,19 @@ module Spontaneous
           end
 
           map "/" do
-            use ::Rack::Lint
-            use Spontaneous::Rack::CSS, :root => Spontaneous.instance.paths.expanded(:public)
-            run Preview
+            run Spontaneous::Rack::Back.preview_app
           end
         end
       end
 
+      class EventListener < ServerBase
+        put "/" do
+          Back.messenger.deliver_event(SSE.new(params))
+          200
+        end
+      end
+
+
       class EditingBase < ServerBase
         set :views, Proc.new { Spontaneous.application_dir + '/views' }
         set :environment, Proc.new { Spontaneous.env }
@@ -117,10 +176,6 @@ module Spontaneous
         helpers Spontaneous::Rack::UserHelpers
         helpers Spontaneous::Rack::Helpers
 
-        def json(response)
-          content_type 'application/json', :charset => 'utf-8'
-          response.serialise_http(user)
-        end
       end
 
       class UnsupportedBrowserHandler < EditingBase
@@ -199,6 +254,7 @@ module Spontaneous
           Content.db.transaction {
             dataset = lock ? Content.for_update : Content
             content = dataset.first(:id => params[:id])
+            content.current_editor = user
             halt 404 if content.nil?
             if box_id = Spontaneous.schema.uids[params[:box_id]]
               box = content.boxes.detect { |b| b.schema_id == box_id }
@@ -209,16 +265,30 @@ module Spontaneous
           }
         end
 
+        def set_authentication_cookie(key)
+          response.set_cookie(AUTH_COOKIE, {
+            :value => key.key_id,
+            :path => '/',
+            :secure => request.ssl?,
+            :httponly => true
+          })
+        end
+
+        def unset_authentication_cookie
+          response.delete_cookie(AUTH_COOKIE, {
+            :path => '/',
+            :secure => request.ssl?,
+            :httponly => true
+          })
+        end
+
         post "/reauthenticate" do
+          origin = "#{NAMESPACE}#{(params[:origin] || "").gsub(%r[^#{NAMESPACE}], "")}"
           if key = Spot::Permissions::AccessKey.authenticate(params[:api_key])
-            response.set_cookie(AUTH_COOKIE, {
-              :value => key.key_id,
-              :path => '/'
-            })
-            origin = "#{NAMESPACE}#{params[:origin]}"
+            set_authentication_cookie(key)
             redirect origin, 302
           else
-            show_login_page( :invalid_key => true )
+            show_login_page( :invalid_key => true, :origin => origin )
           end
         end
 
@@ -226,11 +296,8 @@ module Spontaneous
           login = params[:user][:login]
           password = params[:user][:password]
           origin = "#{NAMESPACE}#{params[:origin]}"
-          if key = Spontaneous::Permissions::User.authenticate(login, password)
-            response.set_cookie(AUTH_COOKIE, {
-              :value => key.key_id,
-              :path => '/'
-            })
+          if key = Spontaneous::Permissions::User.authenticate(login, password, env["REMOTE_ADDR"])
+            set_authentication_cookie(key)
             if request.xhr?
               json({
                 :key => key.key_id,
@@ -244,6 +311,11 @@ module Spontaneous
           end
         end
 
+        post "/logout" do
+          unset_authentication_cookie
+          401
+        end
+
         get '/?' do
           erb :index
         end
@@ -256,29 +328,20 @@ module Spontaneous
           json Site.root
         end
 
-        get '/user' do
-          json(user)
-        end
-        # TODO: check for perms on the particular bit of content
-        # and pass user level into returned JSON
         get '/page/:id' do
           content_for_request { |content| json(content)}
         end
 
-        get '/types' do
-          json Site.schema
+        get '/metadata' do
+          json({
+            :types => Site.schema.export(user),
+            :user  => user.export,
+            :services => (Site.config.services || [])
+          })
         end
 
-        # get '/type/:type' do
-        #   klass = params[:type].gsub(/\\./, "::").constantize
-        #   json klass
-        # end
-
-        get '/map' do
-          json Site.map
-        end
-
-        get '/map/:id' do
+        get '/map/?:id?' do
+          last_modified(Site.modified_at)
           map = Site.map(params[:id])
           if map
             json(map)
@@ -288,6 +351,7 @@ module Spontaneous
         end
 
         get '/location*' do
+          last_modified(Site.modified_at)
           if Page.count == 0
             406
           else
@@ -301,7 +365,6 @@ module Spontaneous
           if Site.root.nil?
             type = Spontaneous.schema[params[:type]]
             root = type.create(:title => "Home")
-            Spontaneous::Change.push(root)
             json({:id => root.id})
           else
             403
@@ -314,6 +377,13 @@ module Spontaneous
           end
         end
 
+        get '/options/:field_sid/:id/?:box_id?' do
+          content_for_request do |content, box|
+            field = (box || content).fields.sid(params[:field_sid])
+            json(field.option_list)
+          end
+        end
+
         def generate_conflict_list(content)
           field_versions = params[:fields]
           conflicts = []
@@ -380,7 +450,7 @@ module Spontaneous
             if target.field_writable?(user, field.name)
               # version = params[:version].to_i
               # if version == field.version
-              field.unprocessed_value = file
+              field.value = file
               content.save
               json(field.export(user))
               # else
@@ -404,7 +474,7 @@ module Spontaneous
                 instance = type.new
                 box.insert(position, instance)
                 field = instance.field_for_mime_type(file[:type])
-                field.unprocessed_value = file
+                field.value = file
                 instance.save
                 content.save
                 json({
@@ -422,8 +492,9 @@ module Spontaneous
           content_for_request(true) do |content, box|
             position = (params[:position] || 0).to_i
             type = Spontaneous.schema[params[:type_name]]#.constantize
+
             if box.writable?(user, type)
-              instance = type.new
+              instance = type.new(:created_by => user)
               box.insert(position, instance)
               content.save
               json({
@@ -469,6 +540,14 @@ module Spontaneous
           end
         end
 
+        post '/slug/:id/titlesync' do
+          content_for_request do |page|
+            page.slug = page.title.unprocessed_value
+            page.save
+            json({:path => page.path, :slug => page.slug })
+          end
+        end
+
         post '/uid/:id' do
           if user.developer?
             content_for_request(true) do |content|
@@ -485,14 +564,21 @@ module Spontaneous
           klass = Spontaneous.schema[params[:schema_id]]
           if klass.alias?
             content_for_request do |content, box|
-              targets = klass.targets(content, box).map do |t|
-                {
-                  :id => t.id,
+              options = {}
+              if (query = params[:query])
+                options[:search] = Regexp.new(query, Regexp::IGNORECASE)
+              end
+              targets = klass.targets(content, box, options).map do |t|
+                { :id => t.id,
                   :title => t.alias_title,
-                  :icon => t.exported_alias_icon
-                }
+                  :icon => t.exported_alias_icon }
               end
-              json(targets)
+              json({
+                :pages => 1,
+                :total => targets.length,
+                :page => 1,
+                :targets => targets
+              })
             end
           end
         end
@@ -502,9 +588,8 @@ module Spontaneous
             type = Spontaneous.schema[params[:alias_id]]
             position = (params[:position] || 0).to_i
             if box.writable?(user, type)
-              target = Spontaneous::Content[params[:target_id]]
-              if target
-                instance = type.create(:target => target)
+              instance = type.for_target(params[:target_id])
+              if instance
                 box.insert(position, instance)
                 content.save
                 json({
@@ -527,14 +612,14 @@ module Spontaneous
         end
 
         post '/publish/publish' do
-          ids = params[:change_set_ids]
+          ids = params[:page_ids]
           ids = ids.blank? ? [] : ids
-          change_sets = ids.map(&:to_i)
-          if change_sets.empty?
+          pages = ids.map(&:to_i)
+          if pages.empty?
             400
           else
             if user.level.can_publish?
-              Site.publish_changes(change_sets)
+              Site.publish_pages(pages)
               json({})
             else
               unauthorised!
@@ -579,7 +664,7 @@ module Spontaneous
             # version = params[:version].to_i
             # if version == field.version
             Spontaneous::Media.combine_shards(params[:shards]) do |combined|
-              field.unprocessed_value = {
+              field.value = {
                 :filename => params[:filename],
                 :tempfile => combined
               }
@@ -606,7 +691,7 @@ module Spontaneous
                 box.insert(position, instance)
                 field = instance.field_for_mime_type(params[:mime_type])
                 Spontaneous::Media.combine_shards(params[:shards]) do |combined|
-                  field.unprocessed_value = {
+                  field.value = {
                     :filename => params[:filename],
                     :tempfile => combined
                   }
@@ -657,11 +742,8 @@ module Spontaneous
             else
               content_type :css
               sass_template = Spontaneous.css_dir / File.basename(file, ".css") + ".scss"
-              less_template = Spontaneous.css_dir / File.basename(file, ".css") + ".less"
               if File.exists?(sass_template)
                 Sass::Engine.for_file(sass_template, :load_paths => [Spontaneous.css_dir], :filename => sass_template, :cache => false).render
-              elsif File.exists?(less_template)
-                Less::Engine.new(File.new(less_template)).to_css
               else
                 raise Sinatra::NotFound
               end
@@ -673,12 +755,12 @@ module Spontaneous
       end
 
       class Preview < Sinatra::Base
+        use CookieAuthentication
+        use AroundPreview
         use Reloader if Site.config.reload_classes
         include Spontaneous::Rack::Public
         helpers Spontaneous::Rack::UserHelpers
 
-        use CookieAuthentication
-        use AroundPreview
 
         set :views, Proc.new { Spontaneous.application_dir + '/views' }
 
@@ -688,12 +770,17 @@ module Spontaneous
         }
 
 
+        # Forward all GETs to the page resolution method
         get '*' do
-          path = params[:splat][0]
+          render_path(params[:splat][0])
+        end
 
-          render_path(path)
+        # Forward all POSTs to the page resolution method
+        post '*' do
+          render_path(params[:splat][0])
         end
 
+        # Override the S::Rack::Public method to add in some cache-busting headers
         def render_page(page, format = :html, local_params = {})
           now = Time.now.to_formatted_s(:rfc822)
           response.headers[HTTP_EXPIRES] = now
@@ -706,3 +793,4 @@ module Spontaneous
     end
   end
 end
+

data/lib/spontaneous/rack/cookie_authentication.rb

@@ -11,14 +11,14 @@ module Spontaneous
         if login = Site.config.auto_login
           user = Spontaneous::Permissions::User[:login => login]
           if user.access_keys.empty?
-            user.generate_access_key
+            user.generate_access_key(env["REMOTE_ADDR"])
           else
             user.access_keys.first
           end
         else
           request = ::Rack::Request.new(env)
           api_key = request.cookies[Spontaneous::Rack::AUTH_COOKIE]
-          if api_key && key = Spontaneous::Permissions::AccessKey.authenticate(api_key)
+          if api_key && key = Spontaneous::Permissions::AccessKey.authenticate(api_key, env["REMOTE_ADDR"])
             key
           else
             nil

data/lib/spontaneous/rack/css.rb

@@ -4,24 +4,28 @@ require 'sass'
 
 module Spontaneous::Rack
   class CSS
+    CSS_EXTENSION = /\.css$/o
+
     def initialize(app, options = {})
-      @options = options
-      @root = options.delete(:root)
+      @roots = options[:root]
       @app = app
     end
 
     def call(env)
-      path = env[S::PATH_INFO]
-      if path =~ /\.css$/ and !File.exists?(File.join(@root, path))
-        template = template_root_path(path) + ".scss"
-        if File.exists?(template)
-          render_sass_template(template)
-        else
-          raise Sinatra::NotFound
-        end
-      else
-        @app.call(env)
+      try_sass(env[S::PATH_INFO]) or @app.call(env)
+    end
+
+    def try_sass(request_path)
+      return nil unless request_path =~ CSS_EXTENSION
+      try_paths = @roots.map { |root| File.join(root, request_path) }
+      # if the css file itself exists then we want to use that
+      return nil if try_paths.detect { |file| ::File.exists?(file) }
+
+      try_paths.each do |path|
+        template = template_path(path)
+        return render_sass_template(template) if File.exists?(template)
       end
+      nil
     end
 
     def render_sass_template(template)
@@ -35,9 +39,8 @@ module Spontaneous::Rack
       [200, {'Content-type' => 'text/css'}, [engine.render]]
     end
 
-    def template_root_path(path)
-      basename = File.basename(path, '.css')
-      File.join(@root, File.dirname(path), basename)
+    def template_path(path)
+      path.gsub(CSS_EXTENSION, ".scss")
     end
   end
 end

data/lib/spontaneous/rack/event_source.rb

@@ -1,31 +1,19 @@
 # encoding: UTF-8
 
+require 'simultaneous'
+
 module Spontaneous
   module Rack
     class EventSource < ::Simultaneous::Rack::EventSource
-      # def initialize
-      #   @messenger = ::Simultaneous::Rack::EventSource.new
-      #   @app = @messenger.app
-      # end
+      def push(client)
+        @lock.synchronize { @clients << client }
+      end
 
-      # def call(env)
-      #   user = env[S::Rack::ACTIVE_USER]
-      #   if user.nil?
-      #     unauthorized!
-      #   else
-      #     request = ::Rack::Request.new(env)
-      #     key = request[S::Rack::KEY_PARAM]
-      #     if ::S::Permissions::AccessKey.valid?(key, user)
-      #       @app.call(env)
-      #     else
-      #       unauthorized!
-      #     end
-      #   end
-      # end
+      alias_method :<<, :push
 
-      # def unauthorized!
-      #   [401, {}, "Unauthorized"]
-      # end
+      def delete(client)
+        @lock.synchronize { removed = @clients.delete(client) }
+      end
     end
   end
 end

data/lib/spontaneous/rack/fiber_pool.rb

@@ -0,0 +1,26 @@
+require 'rack/fiber_pool'
+
+module Spontaneous::Rack
+  class FiberPool
+    def initialize(app, options = {})
+      @target_app = app
+      @options    = options
+    end
+
+    def call(env)
+      app.call(env)
+    end
+
+    def app
+      @app ||= wrap_target_app
+    end
+
+    def wrap_target_app
+      if Spontaneous.async?
+        ::Rack::FiberPool.new(@target_app, @options)
+      else
+        @target_app
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/front.rb

@@ -5,6 +5,13 @@ require 'sinatra/base'
 module Spontaneous
   module Rack
     module Front
+      def self.front_app
+        ::Rack::Builder.app do
+          use AroundFront
+          use Reloader if Site.config.reload_classes
+          run Server.new
+        end
+      end
       def self.application
         app = ::Rack::Builder.new do
           # use ::Rack::CommonLogger, STDERR  #unless server.name =~ /CGI/
@@ -42,19 +49,20 @@ module Spontaneous
           end
 
           map "/" do
-            use AroundFront
-            use Reloader if Site.config.reload_classes
-            run Server.new
+            run Spontaneous::Rack::Front.front_app
           end
         end
       end
+
       class Server < Sinatra::Base
         include Spontaneous::Rack::Public
 
         def call!(env)
           @env = env
           @response = ::Sinatra::Response.new
-          @request = ::Sinatra::Request.new(env)
+          @request  = ::Sinatra::Request.new(env)
+          @params   = indifferent_params(@request.params)
+
           render_path(@request.path_info)
         end
       end

data/lib/spontaneous/rack/helpers.rb

@@ -1,31 +1,53 @@
 # encoding: UTF-8
 
+require 'sprockets'
+
 module Spontaneous
   module Rack
     module Helpers
+      def json(response)
+        content_type 'application/json', :charset => 'utf-8'
+        response.serialise_http(user)
+      end
+
+      def application_assets
+        @application_assets_compiler ||= Spontaneous::Asset::AppCompiler.new(Spontaneous.gem_dir, Spontaneous.root)
+      end
 
       def style_url(style)
-        "#{NAMESPACE}/css/#{style}.css"
+        style = "#{style}.css" unless style =~ /\.css$/
+        if (compiled_asset = application_assets.manifest.assets[style])
+          return "#{NAMESPACE}/assets/#{compiled_asset}"
+        end
+        # TODO: use the sprockets environment to append a modification time to the non-compiled URL
+        "#{NAMESPACE}/css/#{style}"
       end
 
       def script_url(script)
-        "#{NAMESPACE}/js/#{script}.js"
+        script = "#{script}.js" unless script =~ /\.js$/
+
+        if (compiled_asset = application_assets.manifest.assets[script])
+          return "#{NAMESPACE}/assets/#{compiled_asset}"
+        end
+        # TODO: use the sprockets environment to append a modification time to the non-compiled URL
+        "#{NAMESPACE}/js/#{script}"
       end
 
       def script_list(scripts)
-        if Spontaneous.development?
-          scripts.map do |script|
-            src = "/js/#{script}.js"
-            path = Spontaneous.application_dir(src)
+        scripts.map do |script|
+          script = "#{script}.js" unless script =~ /\.js$/
+          src = script_url(script)
+          size = 0
+          if (asset = application_assets.manifest.files[File.basename(src)])
+            size = asset["size"]
+          else
+            src = "#{NAMESPACE}/js/#{script}"
+            path = Spontaneous.application_dir("/js/#{script}")
             size = File.size(path)
-            ["#{NAMESPACE}#{src}", size]
-            # %(<script src="#{NAMESPACE}/js/#{script}.js" type="text/javascript"></script>)
-          end.to_json
-        else
-          # script bundling + compression
-        end
+          end
+          [src, size]
+        end.to_json
       end
     end
   end
 end
-