spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/model/core/fields.rb

@@ -84,7 +84,7 @@ module Spontaneous::Model::Core
     end
 
     def field_versions(field)
-      Spontaneous::Field::FieldVersion.filter(:content_id => self.id, :field_sid => field.schema_id.to_s).order(:created_at.desc)
+      Spontaneous::Field::FieldVersion.filter(:content_id => self.id, :field_sid => field.schema_id.to_s).order(Sequel.desc(:created_at))
     end
 
     def save_field_versions

data/lib/spontaneous/model/core/modifications.rb

@@ -26,7 +26,7 @@ module Spontaneous::Model::Core
       end
 
       def dataset
-        path_like = :ancestor_path.like("#{owner[:ancestor_path]}.#{owner.id}%")
+        path_like = Sequel.like(:ancestor_path, "#{owner[:ancestor_path]}.#{owner.id}%")
         owner.content_model.filter(path_like)
       end
 
@@ -76,7 +76,7 @@ module Spontaneous::Model::Core
       end
 
       def dataset
-        path_like = :visibility_path.like("#{owner[:visibility_path]}.#{owner.id}%")
+        path_like = Sequel.like(:visibility_path, "#{owner[:visibility_path]}.#{owner.id}%")
         owner.content_model::Page.filter(path_like)
       end
     end

data/lib/spontaneous/model/core/page_search.rb

@@ -14,6 +14,10 @@ module Spontaneous::Model::Core
         path(Spontaneous::SLASH)
       end
 
+      def id(id)
+        first_visible("id:#{id}", :id => id)
+      end
+
       def uid(uid)
         first_visible("uid:#{uid}", :uid => uid)
       end

data/lib/spontaneous/model/core/publishing.rb

@@ -7,19 +7,6 @@ module Spontaneous::Model::Core
 
     module ClassMethods
 
-      # def current_revision_table
-      #   revision_table(revision)
-      # end
-
-      # def base_table
-      #   mapper.base_table
-      # end
-
-      # make sure that the table name is always the correct revision
-      # def simple_table
-      #   current_revision_table
-      # end
-
       def revision_table(revision=nil)
         mapper.revision_table(revision)
       end
@@ -66,12 +53,12 @@ module Spontaneous::Model::Core
         mapper.editable!(&block)
       end
 
-      def with_published(&block)
-        scope(Spontaneous::Site.published_revision, true, &block)
+      def with_published(site, &block)
+        scope(site.published_revision, true, &block)
       end
 
-      def with_published!(&block)
-        scope!(Spontaneous::Site.published_revision, true, &block)
+      def with_published!(site, &block)
+        scope!(site.published_revision, true, &block)
       end
 
       def database

data/lib/spontaneous/model/core/render.rb

@@ -9,13 +9,13 @@ module Spontaneous::Model::Core
       raise "Cannot render content without enclosing page"
     end
 
-    def render(format = :html, params = {}, *args)
+    def render(format = :html, params = {}, parent_context = nil)
       params, format = format, :html if format.is_a?(Hash)
-      output(format).render(params, *args)
+      output(format).render(params, parent_context)
     end
 
-    def render_using(renderer, format = :html, params = {}, *args)
-      output(format).render_using(renderer, params, *args)
+    def render_using(renderer, format = :html, params = {}, parent_context = nil)
+      output(format).render_using(renderer, params, parent_context)
     end
   end
 end

data/lib/spontaneous/model/core/styles.rb

@@ -108,8 +108,8 @@ module Spontaneous::Model::Core
       self.class.styles
     end
 
-    def template(format = :html)
-      style.template(format)
+    def template(format = :html, renderer = Spontaneous::Output.default_renderer)
+      style.template(format, renderer)
     end
   end
 end

data/lib/spontaneous/model/core/visibility.rb

@@ -104,7 +104,7 @@ module Spontaneous::Model::Core
     end
 
     def hide_descendents(visible)
-      path_like = :visibility_path.like("#{self[:visibility_path]}.#{self.id}%")
+      path_like = Sequel.like(:visibility_path, "#{self[:visibility_path]}.#{self.id}%")
       origin = visible ? nil : self.id
       dataset = content_model.filter(path_like).filter(:hidden => visible)
       # if a child item has been made invisible *before* its parent then it exists
@@ -127,8 +127,12 @@ module Spontaneous::Model::Core
     end
 
     def visibility_ancestors
+      visibility_ancestor_ids.map { |id| content_model[id] }
+    end
+
+    def visibility_ancestor_ids
       return [] if visibility_path.blank?
-      visibility_path.split(Spontaneous::VISIBILITY_PATH_SEP).map { |id| content_model[id] }
+      visibility_path.split(Spontaneous::VISIBILITY_PATH_SEP).map(&:to_i)
     end
 
     def recalculated_hidden

data/lib/spontaneous/model/page.rb

@@ -6,7 +6,6 @@ require "spontaneous/model/page/layouts"
 require "spontaneous/model/page/locks"
 require "spontaneous/model/page/page_tree"
 require "spontaneous/model/page/paths"
-require "spontaneous/model/page/request"
 require "spontaneous/model/page/site_map"
 require "spontaneous/model/page/site_timestamps"
 
@@ -20,7 +19,6 @@ module Spontaneous::Model
     include Layouts
     include PageTree
     include Paths
-    include Request
     include SiteMap
     include SiteTimestamps
     include Locks
@@ -147,5 +145,11 @@ module Spontaneous::Model
     def inspecttion_values
       { :id => id, :uid => uid, :path => path }.merge(inspection_fields)
     end
+
+    # PagePieces are == to their target but we must enforce the reverse,
+    # that Pages are == to a PagePiece that encloses them
+    def eql?(obj)
+      super || (Spontaneous::PagePiece === obj && obj.target.eql?(self))
+    end
   end
 end

data/lib/spontaneous/model/page/controllers.rb

@@ -11,36 +11,74 @@ module Spontaneous::Model::Page
         @controllers ||= Spontaneous::Collections::PrototypeSet.new(supertype, :controllers)
       end
 
-      def controller_base_class
-        return ::PageController if defined?(::PageController)
-        default_controller_base_class
-      end
-
       def default_controller_base_class
         Spontaneous::Rack::PageController
       end
 
-      def controller(namespace, base_class = controller_base_class, &block)
-        controller_class_name = "#{namespace.to_s.camelize}Controller"
-        controller_class = Class.new(base_class)
+      # Searches through the type heirarchy for the first defined controller
+      # if there isn't one for the given namespace it tries on the 'default'
+      # namespace
+      def controller_superclass(namespace, base_class)
+        return base_class unless base_class.nil?
+        return ::PageController if defined?(::PageController)
+        search = ancestors.select { |klass| klass.respond_to?(:controllers) }
+        controller_superclass = [namespace, :__nil__].uniq.flat_map { |n|
+          search.map { |type| type.controllers[n] }
+        }.compact.first
+        controller_superclass ||= default_controller_base_class
+      end
+
+      def controller(namespace = :__nil__, base_class = nil, &block)
+        namespace_name = (namespace == :__nil__ ? "Root" : namespace.to_s.camelize)
+        controller_class = Class.new(controller_superclass(namespace, base_class))
+        const_set("#{namespace_name}Controller", controller_class)# unless self.const_defined?(controller_class_name)
         controller_class.class_eval(&block) if block_given?
-        self.const_set(controller_class_name, controller_class) unless self.const_defined?(controller_class_name)
-        controllers[namespace.to_sym] = controller_class
+        controllers[namespace] = controller_class
+      end
+
+      METHOD_MAP = Hash[%w(GET PUT POST DELETE HEAD OPTIONS PATCH LINK UNLINK).map { |m| [m, m.downcase.to_sym] }].freeze
+
+      def normalize_method(method)
+        return method if method.is_a?(Symbol)
+        METHOD_MAP[method]
+      end
+
+      # Tests for existance of a request handler for a method
+      # Used by the publishing mechanism to determine which template bucket a
+      # published page should be placed in.
+      def dynamic?(method = :get)
+        method = normalize_method(method)
+        return true unless method == :get
+        controller = controllers[:__nil__]
+        controller and controller.dynamic?(method)
       end
     end # ClassMethods
 
     # InstanceMethods
 
+    def dynamic?(method = :get)
+      self.class.dynamic?(method)
+    end
+
     # resolve and call the relevant action handler and return the results to the controller
-    def process_action(action_path, env, format)
-      env = env.dup
-      namespace, *p = action_path.split(S::Constants::SLASH)
-      path = [S::Constants::EMPTY].concat(p).join(S::Constants::SLASH)
+    def process_action(site, action_path, env, format)
+      namespace, *parts = action_path.split(S::Constants::SLASH)
+      path = "/" << parts.join(S::Constants::SLASH)
       env[S::Constants::PATH_INFO] = path
+      run_controller(site, namespace, env, format)
+    end
+
+    def process_root_action(site, env, format)
+      env[S::Constants::PATH_INFO] = S::Constants::SLASH
+      run_controller(site, :__nil__, env, format)
+    end
+
+    def run_controller(site, namespace, env, format)
       controller_class = self.class.controllers[namespace.to_sym]
-      return 404 unless controller_class
-      app = controller_class.new(self, format)
-      app.call(env)
+      return 404 if controller_class.nil?
+      app = controller_class.new(site, self, format)
+      status, headers, body = app.call(env)
+      [status, headers, body]
     end
 
     # generate an action URL of the form

data/lib/spontaneous/model/page/formats.rb

@@ -55,10 +55,15 @@ module Spontaneous::Model::Page
         output_list.first
       end
 
-      def provides_format?(format)
+      def provides_format?(format, instance = nil)
         return true if format.blank?
-        format = format.to_s
-        outputs.any? { |output| (output == format) or (output.name.to_s == format) }
+        format_name = format.to_s
+        case format
+        when Spontaneous::Output::Format
+          (instance.nil? || (format.page == instance)) && outputs.any? { |output| (output.to_sym == format.to_sym) }
+        else
+          outputs.any? { |output| output.name.to_s == format_name }
+        end
       end
 
       alias_method :provides_output?, :provides_format?
@@ -92,7 +97,7 @@ module Spontaneous::Model::Page
     end
 
     def provides_output?(format)
-      self.class.provides_output?(format)
+      self.class.provides_output?(format, self)
     end
 
     def output(format, content = nil)
@@ -105,10 +110,10 @@ module Spontaneous::Model::Page
       self.class.mime_type(format)
     end
 
-    def render(format=:html, params={}, *args)
-      params, format = format, :html if format.is_a?(Hash)
+    def render(format = :html, locals = {}, parent_context = nil)
+      locals, format = format, :html if format.is_a?(Hash)
       output = output(format)
-      output.render(params, *args)
+      output.render(locals, parent_context)
     end
   end # Formats
 end # Spontaneous::Plugins::Page

data/lib/spontaneous/model/page/layouts.rb

@@ -86,8 +86,8 @@ module Spontaneous::Model::Page
       self.class.find_named_layout(layout_name)
     end
 
-    def template(format = :html)
-      layout.template(format)
+    def template(format = :html, renderer = Spontaneous::Output::default_renderer)
+      layout.template(format, renderer)
     end
   end # Layouts
 end # Spontaneous::Plugins

data/lib/spontaneous/model/page/locks.rb

@@ -5,7 +5,10 @@ module Spontaneous::Model::Page
     extend Spontaneous::Concern
 
     included do
-      one_to_many :update_locks, :class => Spontaneous::PageLock, :key => :page_id
+      one_to_many :update_locks, class: Spontaneous::PageLock, key: :page_id
+
+      Spontaneous::PageLock.many_to_one :page,    class: model, key: :page_id
+      Spontaneous::PageLock.many_to_one :content, class: model, key: :content_id
     end
 
     def locked_for_update?

data/lib/spontaneous/model/page/page_tree.rb

@@ -15,18 +15,52 @@ module Spontaneous::Model::Page
     end
 
     # Returns a list of all the pages at a certain depth in the page tree for any page
-    def at_depth(depth)
+    def at_depth(depth, opts = {})
       return root_at_depth(depth) if is_root?
       parent_depth = [0, depth - 1].max
-      parent = ancestor(parent_depth)
-      unordered_pages = parent.children
+      parent       = ancestor(parent_depth)
       # This is made more complex because the #children method is unordered
       # whereas the actual page order must come from the boxes
-      return unordered_pages if parent.boxes.empty?
-      ordered_pages = []
+      return parent.children if parent.boxes.empty?
+
       # Iterate through the list of boxes and pull out of the
       # unordered page list each page that belongs to the current box
-      parent.boxes.each do |box|
+      boxes = parent.boxes
+
+      filter_proc = filter_list = nil
+
+      if (filter_list = (opts.delete(:only) || opts.delete(:box) || opts.delete(:boxes)))
+        filter_proc = proc { |box| filter_list.include?(box._name) }
+      elsif (filter_list = opts.delete(:except))
+        filter_proc = proc { |box| !filter_list.include?(box._name) }
+      end
+
+      if filter_list && filter_proc
+        filter_list = Array(filter_list).map(&:to_sym)
+        boxes  = boxes.select(&filter_proc)
+      end
+
+      ordered_pages = parent.ordered_pages(boxes)
+
+      filter_proc = filter_list = nil
+
+      if (filter_list = opts.delete(:include))
+        filter_proc = proc { |p| filter_list.include?(p.class) }
+      elsif (filter_list = opts.delete(:exclude))
+        filter_proc = proc { |p| !filter_list.include?(p.class) }
+      end
+
+      if filter_list && filter_proc
+        filter_list = Array(filter_list).map { |s| Class === s ? s : s.to_s.constantize }
+        ordered_pages = ordered_pages.select(&filter_proc)
+      end
+      ordered_pages
+    end
+
+    def ordered_pages(boxes)
+      unordered_pages = self.children
+      ordered_pages   = []
+      boxes.each do |box|
         box_id = box.schema_id.to_s
         in_box, unordered_pages = unordered_pages.partition { |p| p.box_sid == box_id }
         ordered_pages.concat in_box.sort { |a, b| a.position <=> b.position }

data/lib/spontaneous/output.rb

@@ -52,37 +52,6 @@ module Spontaneous
       end
     end
 
-    def self.output_path(revision, output, template_dynamic = false, request_method = "GET")
-      output_path_with_root(revision_root(revision), revision, output, template_dynamic, request_method)
-    end
-
-    def self.output_path_with_root(root, revision, output, template_dynamic = false, request_method = "GET")
-      segment = case
-                when template_dynamic || output.dynamic?
-                  "dynamic"
-                when output.page.dynamic?(request_method)
-                  "protected"
-                else
-                  "static"
-                end
-      path = output.page.path
-      dir  = root / segment / path
-      ext  = output.extension(template_dynamic)
-
-      file = "#{dir}#{ext}"
-      file = dir / "/index#{ext}" if path == "/" # root is a special case, as always
-      file
-    end
-
-    # TODO: Is this ever used? Delete it & see what breaks
-    def self.revision_dir(revision=nil, root = nil)
-      Spontaneous::Site.instance.revision_dir(revision, root)
-    end
-
-    def self.revision_root(revision)
-      Spontaneous::Site.instance.revision_dir(revision)
-    end
-
     def self.context_class
       Cutaneous::Context
     end
@@ -120,28 +89,19 @@ module Spontaneous
       Cutaneous::Engine
     end
 
-    def self.renderer
-      @renderer ||= default_renderer
-    end
-
-    def self.renderer=(renderer)
-      @renderer = renderer
-    end
-
-    def self.default_renderer
-      Template::Renderer.new
-    end
-
-    def self.published_renderer(revision = Spontaneous::State.published_revision)
-      Template::PublishedRenderer.new(revision)
+    # Used in the console or any other place where we want to render
+    # content outside of the Rack applications or publishing
+    # system
+    def self.default_renderer(site = Spontaneous::Site.instance)
+      Template::Renderer.new(site)
     end
 
-    def self.preview_renderer
-      Template::PreviewRenderer.new
+    def self.published_renderer(site, revision = Spontaneous::State.published_revision)
+      Template::PublishedRenderer.new(site, revision)
     end
 
-    def self.template_exists?(root, template, format)
-      renderer.template_exists?(root, template, format)
+    def self.preview_renderer(site)
+      Template::PreviewRenderer.new(site)
     end
 
     def self.asset_url(file = nil)
@@ -152,9 +112,11 @@ module Spontaneous
       Spontaneous.revision_dir(revision) / asset_url
     end
 
-    autoload :Template, "spontaneous/output/template"
-    autoload :Context,  "spontaneous/output/context"
-    autoload :Helpers,  "spontaneous/output/helpers"
+    autoload :Template,   "spontaneous/output/template"
+    autoload :Context,    "spontaneous/output/context"
+    autoload :Helpers,    "spontaneous/output/helpers"
+    autoload :Renderable, "spontaneous/output/renderable"
+    autoload :Store,      "spontaneous/output/store"
   end
 end