spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/rack/js.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require 'coffee-script'
+
+module Spontaneous::Rack
+  class JS
+    JS_EXTENSION = /\.js$/o
+
+    def initialize(app, options = {})
+      @roots = options[:root]
+      @app = app
+    end
+
+    def call(env)
+      try_coffeescript(env[S::PATH_INFO]) or @app.call(env)
+    end
+
+    def try_coffeescript(request_path)
+      return nil unless request_path =~ JS_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_coffeescript(template) if File.exists?(template)
+      end
+      nil
+    end
+
+    def render_coffeescript(template)
+      script = CoffeeScript.compile(File.read(template))
+      [200, {'Content-type' => 'application/javascript;charset=utf-8'}, StringIO.new(script)]
+    end
+
+    def template_path(path)
+      path.gsub(JS_EXTENSION, ".coffee")
+    end
+  end
+end
+

data/lib/spontaneous/rack/public.rb

@@ -13,6 +13,7 @@ module Spontaneous
       attr_accessor :page
 
       def render_path(path)
+        @template_params = {}
         find_page!(path)
 
         response = catch(:halt) do
@@ -52,7 +53,7 @@ module Spontaneous
       # stolen from Sinatra
       def parse_response(response)
         case
-        when response.respond_to?(:spontaneous_content?)
+        when response.is_a?(Spontaneous::Content)
           @page = response
         when response.respond_to?(:to_str)
           @response.body = [response]
@@ -88,6 +89,11 @@ module Spontaneous
         status(status)
       end
 
+      def render(page, template_params = {})
+        @template_params = template_params
+        show(page)
+      end
+
       REDIRECTS = {
         :permanent => 301,
         :temporary => 302
@@ -122,12 +128,12 @@ module Spontaneous
       end
 
       def find_page!(path)
-        @path, @format, @action = parse_path(path)
+        @path, @output, @action = parse_path(path)
         @page = Site[@path]
       end
 
-      def format
-        @format
+      def output
+        @output
       end
 
       def action
@@ -135,25 +141,17 @@ module Spontaneous
       end
 
       def render_get
-        # return not_found! unless @page
-
-        @format = (@format || @page.default_format).to_sym if @page
-
         if @action
           call_action!
         else
           block = page.request_block(request)
           parse_response(instance_eval(&block)) if (block)
-
-          @format = (@format || @page.default_format).to_sym if @page
-          render_page_with_format(@page, @format)
+          render_page_with_output
         end
       end
 
       # non-action urls shouldn't respond to post requests
       def render_post
-        # return not_found! unless @page
-
         block = page.request_block(request)
         return not_found! unless (block or @action)
 
@@ -161,21 +159,18 @@ module Spontaneous
           call_action!
         else
           parse_response(instance_eval(&block)) if (block)
-
-          @format = (@format || @page.default_format).to_sym if @page
-          render_page_with_format(@page, @format)
+          render_page_with_output
         end
       end
 
       def call_action!
-        # get
-        status, headers, result = @page.process_action(action, request.env, format)
-        # our 404 page should come from the CMS
+        status, headers, result = @page.process_action(action, request.env, output)
         if status == 404
           not_found!
         else
-          if result.respond_to?(:spontaneous_content?)
-            render_page_with_format(result, format)
+          if result.is_a?(Spontaneous::Content)
+            @page = result
+            render_page_with_output
           else
             [status, headers, result]
           end
@@ -185,46 +180,41 @@ module Spontaneous
       def parse_path(path)
         if path =~ %r(#{ACTION})
           path, action = path.split(ACTION)
+          path = "/" if path.empty?
           action, format = action.split(DOT)
         else
           path, format = path.split(DOT)
         end
-        # format = (format || :html).to_sym
         [path, format, action]
       end
 
-      def render_page_with_format(page, format)
-        if page && page.provides_format?(format)
-          content_type(page.mime_type(format))
-          render_page(page, format)
+      def render_page_with_output
+        return not_found! if     @page.nil?
+        return not_found! unless @page.provides_output?(@output)
+
+        output = @page.output(@output)
+
+        if output.public?
+          content_type(output.mime_type)
+          render_page(@page, output, @template_params)
         else
-          # perhaps we should return the html version if the page exists but
-          # doesn't respond to the requested format?
-          # or even redirect to the html?
           not_found!
         end
       end
 
-      def render_page(page, format = :html, local_params = {})
-        response.body = page.render(format, local_params.merge({
-          :params => request.params,
+      def renderer
+        env[Rack::RENDERER]
+      end
+
+      def render_page(page, output, local_params = {})
+        response.body = output.render_using(renderer, local_params.merge({
+          :params  => params, # use sinatras indifferent params
           :request => request,
           :session => request.session
         }))
       end
 
-      # def redirect?(page)
-      #   redirection, redirect_code = page.request_redirect(request.params, request, request.session)
-      #   if redirection
-      #     redirection = redirection.path if redirection.respond_to?(:path)
-      #     redirect_code = REDIRECTS[redirect_code] if Symbol === redirect_code
-      #     redirect_code ||= REDIRECTS[:temporary]
-      #     [redirection.to_s, redirect_code]
-      #   else
-      #     nil
-      #   end
-      # end
-
+      # our 404 page should come from the CMS
       def not_found!
         404
       end

data/lib/spontaneous/rack/sse.rb

@@ -0,0 +1,18 @@
+
+module Spontaneous
+  module Rack
+    class SSE
+      attr_reader :event, :data
+
+      def initialize(params)
+        @event = params[:event]
+        @data  = params[:data]
+      end
+
+      def to_sse
+        lines = ["event: #{event}", "data: #{data}", "\n"]
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/static.rb

@@ -2,6 +2,8 @@
 module Spontaneous
   module Rack
     class Static
+      ALLOWED_METHODS = %w(GET HEAD).freeze
+
       def initialize(app, options)
         @app = app
         @try = ['', *options.delete(:try)].compact
@@ -11,6 +13,7 @@ module Spontaneous
       end
 
       def call(env)
+        return @app.call(env) unless ALLOWED_METHODS.include?(env[S::REQUEST_METHOD])
         orig_path = env['PATH_INFO']
         found = nil
         @try.each do |path|

data/lib/spontaneous/rack/user_admin.rb

@@ -0,0 +1,100 @@
+module Spontaneous::Rack
+  class UserAdmin < ServerBase
+    helpers UserHelpers
+    helpers Helpers
+
+    User = Spontaneous::Permissions::User unless defined?(User)
+
+    def with_account
+      User.db.transaction do
+        account = User.for_update.first(:id => params[:user_id])
+        halt 403 unless user.level >= account.level
+        yield account
+      end
+    end
+
+    def load_level
+      attr = params[:user]
+      level_name = attr.delete(:level) || attr.delete("level")
+      return nil if level_name.blank?
+      level = Spontaneous::Permissions[level_name]
+      halt 403 unless user.level >= level
+      level
+    end
+
+    before {
+      halt 403 unless user.admin?
+    }
+
+    get "/" do
+      json User.export(user)
+    end
+
+    post "/" do
+      level   = load_level
+      account = User.new params[:user]
+      if account.save
+        account.update(:level => level)
+        json User.export_user(account)
+      else
+        status 422
+        json account.errors#.full_messages
+      end
+    end
+
+    put "/:user_id" do
+      with_account do |account|
+        level = load_level
+        account.update_fields(params[:user], [:login, :name, :email])
+        if account.save
+          account.update(:level => level) if level
+          json User.export_user(account)
+        else
+          status 422
+          json account.errors#.full_messages
+        end
+      end
+    end
+
+    delete "/:user_id" do
+      with_account do |account|
+        account.destroy
+        200
+      end
+    end
+
+    put "/password/:user_id" do
+      with_account do |account|
+        account.password = params[:password]
+        if account.save
+          # TODO: changing the password should log the user out?
+          200
+        else
+          status 422
+          json account.errors#.full_messages
+        end
+      end
+    end
+
+    delete "/keys/:user_id" do
+      with_account do |account|
+        account.clear_access_keys!
+        200
+      end
+    end
+
+    put "/disable/:user_id" do
+      with_account do |account|
+        account.disable!
+        200
+      end
+    end
+
+    put "/enable/:user_id" do
+      with_account do |account|
+        account.enable!
+        200
+      end
+    end
+  end
+end

data/lib/spontaneous/rack/user_helpers.rb

@@ -5,7 +5,7 @@ module Spontaneous
     module UserHelpers
 
       def unauthorised!
-        halt 401#, "You do not have the necessary permissions to update the '#{name}' field"
+        halt 403#, "You do not have the necessary permissions to update the '#{name}' field"
       end
 
       def api_key

data/lib/spontaneous/rack.rb

@@ -1,8 +1,7 @@
 # encoding: UTF-8
 
 require "rack"
-# require "sinatra"
-require 'sinatra/base'
+require "sinatra/base"
 
 module Spontaneous
   module Rack
@@ -11,6 +10,7 @@ module Spontaneous
     ACTIVE_KEY  = "SPONTANEOUS_KEY".freeze
     AUTH_COOKIE = "spontaneous_api_key".freeze
     KEY_PARAM   = "__key".freeze
+    RENDERER    = "spot.renderer".freeze
 
     EXPIRES_MAX = DateTime.parse("Thu, 31 Dec 2037 23:55:55 GMT").httpdate
 
@@ -54,6 +54,7 @@ module Spontaneous
     autoload :CacheableFile,        'spontaneous/rack/cacheable_file'
     autoload :Static,               'spontaneous/rack/static'
     autoload :UserHelpers,          'spontaneous/rack/user_helpers'
+    autoload :UserAdmin,            'spontaneous/rack/user_admin'
     autoload :Helpers,              'spontaneous/rack/helpers'
     autoload :CookieAuthentication, 'spontaneous/rack/cookie_authentication'
     autoload :QueryAuthentication,  'spontaneous/rack/query_authentication'
@@ -63,5 +64,8 @@ module Spontaneous
     autoload :Reloader,             'spontaneous/rack/reloader'
     autoload :EventSource,          'spontaneous/rack/event_source'
     autoload :CSS,                  'spontaneous/rack/css'
+    autoload :JS,                   'spontaneous/rack/js'
+    autoload :SSE,                  'spontaneous/rack/sse'
+    autoload :FiberPool,            'spontaneous/rack/fiber_pool'
   end
 end

data/lib/spontaneous/schema.rb

@@ -208,7 +208,7 @@ module Spontaneous
         # will check that each of the classes in the schema has a
         # corresponding id
         self.classes.each do | schema_class |
-          schema_class.schema_validate
+          schema_class.schema_validate(self)
         end
 
         # now check that each of the ids in the map has a
@@ -227,15 +227,15 @@ module Spontaneous
       end
 
 
-      def export
+      def export(user = nil)
         self.content_classes.inject({}) do |hash, klass|
-          hash[klass.ui_class] = klass.export
+          hash[klass.ui_class] = klass.export(user)
           hash
         end
       end
 
       def serialise_http(user = nil)
-        Spontaneous.serialise_http(export)
+        Spontaneous.serialise_http(export(user))
       end
 
       # all classes including boxes
@@ -321,6 +321,33 @@ module Spontaneous
       def [](schema_id)
         map[schema_id]
       end
+
+      def groups
+        @groups ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def add_group_member(schema_class, group_names)
+        group_names.each do |name|
+          group = groups[name.to_sym]
+          group << schema_class.to_s unless group.include?(schema_class.to_s)
+        end
+      end
+
+      def is_group?(group_name)
+        groups.key?(group_name.to_sym)
+      end
+
+      def group_memberships(klass)
+        classname = klass.to_s
+        groups.select { |group, members| members.include?(classname) }.keys
+      end
+
+      def remove_group_members(klass)
+        type = klass.to_s
+        groups.each do |group, members|
+          members.delete(type)
+        end
+      end
     end
   end
 end

data/lib/spontaneous/search/index.rb

@@ -67,19 +67,35 @@ module Spontaneous::Search
       values = Hash.new { |h, k| h[k] = [] }
       # not sure that I need the include? test here as page.content only returns Pieces
       # and I'm not sure that there is a particular need to exclude Pieces from indexes
-      pieces = [page].concat(page.content).select { |content| include?(content) }
-      pieces += page.boxes.select { |box| include?(box) }
-      pieces.each do |content|
+      indexable = [page]
+      indexable.concat(page.pieces.select { |content| include?(content) })
+      indexable += page.boxes.select { |box| include?(box) }
+      indexable.each do |content|
         content.fields.each do |field|
           prototype = field.prototype
           values[prototype.index_id(self)] << field.indexable_value if prototype.in_index?(self)
         end
+        insert_additional_indexable_values(content, values)
       end
       result = Hash[ values.map { |id, values| [id, values.join("\n")] } ]
       result[:id] = page.id
       result
     end
 
+    def insert_additional_indexable_values(content, values)
+      if content.respond_to?(:additional_search_values)
+        add = content.additional_search_values
+        case add
+        when Array
+          add.each do |row|
+            row.each { |k, v| values[k.to_s] << v }
+          end
+        when Hash
+          add.each { |k, v| values[k.to_s] << v }
+        end
+      end
+    end
+
     def fields
       field_lists = Hash.new { |h, k| h[k] = [] }
       # collect all the definitions for a particular field or group

data/lib/spontaneous/search/results.rb

@@ -28,7 +28,7 @@ module Spontaneous::Search
     end
 
     def pages
-      @page_list ||= Spontaneous::Content.filter(:id => @results.map { |doc| doc.id })
+      @page_list ||= @results.map { |doc| Spontaneous::Content.first(:id => doc.id) }
     end
   end # Results
 end

data/lib/spontaneous/sequel.rb

@@ -0,0 +1,17 @@
+require "sequel"
+
+Sequel.extension :inflector
+
+require 'sequel/plugins/serialization'
+
+# Sequel::Plugins::Serialization.register_format(
+#   :yajl,
+#   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)   }
+)
+

data/lib/spontaneous/site.rb

@@ -4,7 +4,7 @@ module Spontaneous
   class Site < Spontaneous::Facet
     include Plugins::Site::Instance
     include Plugins::Site::Publishing
-    include Plugins::Site::Revisions
+    include Plugins::Site::State
     include Plugins::Site::Selectors
     include Plugins::Site::Map
     include Plugins::Site::Search
@@ -12,6 +12,10 @@ module Spontaneous
     include Plugins::Site::Schema
     include Plugins::Site::Level
     include Plugins::Site::Storage
+    include Plugins::Site::URL
+    include Plugins::Site::Hooks
+    include Plugins::Site::Paths
+    include Plugins::Site::Helpers
 
     attr_accessor :database
     attr_reader :environment, :mode
@@ -102,14 +106,17 @@ module Spontaneous
     end
 
     def revision_root
-      @revision_dir ||= File.expand_path(@root / 'cache/revisions')
-      # Spontaneous.relative_dir(@revision_dir, *path)
+      @revision_dir ||= begin
+                          path = Pathname.new(@root / 'cache/revisions')
+                          path.mkpath unless path.exist?
+                          path.realpath.to_s
+                        end
     end
 
     def revision_dir(revision=nil, root = revision_root)
       root ||= revision_root
       return root / 'current' if revision.nil?
-      root / revision.to_s.rjust(5, "0")
+      root / Spontaneous::Paths.pad_revision_number(revision)
     end
 
     def media_dir(*path)

data/lib/spontaneous/state.rb

@@ -48,6 +48,17 @@ module Spontaneous
         instance.pending_revision
       end
 
+      # Returns the last date at which a Page was added or removed from the site
+      # Used to avoid un-necessary loading of the navigation map during editing
+      def modified_at
+        instance.modified_at || Time.now
+      end
+
+      # Called by Page.after_create and Page.after_destroy in order to update
+      # the Site's modification time
+      def site_modified!
+        instance.update :modified_at => Time.now
+      end
     end
   end
 end

data/lib/spontaneous/storage/cloud.rb

@@ -35,6 +35,9 @@ module Spontaneous::Storage
     #
     attr_reader :bucket_name
 
+    # Don't verify my ssl certs when uploading images
+    ::Excon.defaults[:ssl_verify_peer] = false
+
     def initialize(config, bucket_name, accepts = nil)
       @config, @bucket_name, @accepts = config, bucket_name, accepts
       @public_host = @config.delete(:public_host)
@@ -55,6 +58,7 @@ module Spontaneous::Storage
         :idempotent => false,
         :body => existing_file,
         :public => true,
+        :expires => (DateTime.now + 20.years).to_s(:rfc822),
         :content_type => mimetype
       }
       params[:body] = File.open(existing_file) if existing_file.is_a?(String)

data/lib/spontaneous/storage/local.rb

@@ -10,6 +10,12 @@ module Spontaneous::Storage
 
     def copy(existing_file, media_path, mimetype)
       dest_path = create_absolute_path(media_path)
+      copy_file(existing_file, dest_path)
+      set_permissions(dest_path)
+      dest_path
+    end
+
+    def copy_file(existing_file, dest_path)
       if existing_file.respond_to?(:read)
         File.open(dest_path, "wb") do |f|
           f.binmode
@@ -28,6 +34,7 @@ module Spontaneous::Storage
         f.binmode
         block.call(f)
       end
+      set_permissions(dest_path)
     end
 
     def create_absolute_path(relative_path)
@@ -48,5 +55,9 @@ module Spontaneous::Storage
     def local?
       true
     end
+
+    def set_permissions(filepath)
+      File.chmod(0644, filepath)
+    end
   end
 end

data/lib/spontaneous/style.rb

@@ -40,9 +40,9 @@ module Spontaneous
 
     def local_template(format)
       template_path = nil
-      Spontaneous.template_paths.each do |template_root|
+      Site.paths(:templates).each do |template_root|
         template_path = try_template_paths.detect do |path|
-          Spontaneous::Render.exists?(template_root, path, format)
+          Spontaneous::Output.template_exists?(template_root, path, format)
         end
         return (template_root / template_path) if template_path
       end