spontaneous 0.2.0.beta5 → 0.2.0.beta6

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

@@ -4,22 +4,6 @@ module Spontaneous::Model::Core
   module Entries
     extend Spontaneous::Concern
 
-    # before_include do
-    #   puts "owner= defined?"
-    #   p method_defined?(:owner=)
-    # end
-
-    # included do
-    #   # alias_method :<<, :push
-    # end
-    #
-    #     def self.configure(base)
-    #       base.__send__(:alias_method,  :<<, :push)
-    #     end
-
-    # InstanceMethods
-
-
     # because it's possible to build content out of order
     # some relations don't necessarily get created straight away
     def before_save
@@ -73,9 +57,6 @@ module Spontaneous::Model::Core
     end
 
     def entry_modified!(modified_entry)
-      # See plugins/modifications.rb for details of __ignore_page_modification ... basically
-      # it stops the parent page appearing in the publishing list when a new page is added.
-      @__ignore_page_modification = modified_entry && modified_entry.added? && modified_entry.page?
       self.entry_store = all_contents.serialize_db
     end
 

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

@@ -73,6 +73,11 @@ module Spontaneous::Model::Core
 
     # InstanceMethods
 
+    def before_create
+      serialize_fields(fields.with_dynamic_default_values)
+      super
+    end
+
     def after_save
       super
       fields.saved
@@ -106,6 +111,12 @@ module Spontaneous::Model::Core
       @field_set ||= Spontaneous::Collections::FieldSet.new(self, field_store)
     end
 
+    # Used by #content_hash to attempt to preserve content hashes across
+    # schema changes
+    def fields_with_consistent_order
+      fields.sort { |f1, f2| f1.schema_id <=> f2.schema_id }
+    end
+
     def field?(field_name)
       self.class.field?(field_name)
     end

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

@@ -110,13 +110,6 @@ module Spontaneous::Model::Core
     end
 
     def before_save
-      # Home of many hacks.
-      #
-      # @__ignore_page_modification is set if a box has been modified by the addition of a page.
-      # This is to correctly map changes to a list of pages to publish. In the case of a page
-      # addition the change is owned by the new page.
-      self.modified_at = Time.now unless @__ignore_page_modification or changed_columns.empty?
-      @__ignore_page_modification = false
       # marks this object as the modified object appending modifications to the list
       # needed in order to know if changes to the modification list will be saved automatically
       # or if we need an explicit call to #save
@@ -134,9 +127,7 @@ module Spontaneous::Model::Core
     end
 
     def generate_modification_list
-      create_slug_modifications
-      create_visibility_modifications
-      serialize_pending_modifications
+      serialize_pending_modifications if [create_slug_modifications, create_visibility_modifications].any? { |result| result }
     end
 
     def child_page_deleted!
@@ -159,28 +150,32 @@ module Spontaneous::Model::Core
     def create_visibility_modifications
       # We only want to record visibility changes that originate from user action, not ones propagated
       # from higher up the tree, hence the check against the hidden_origin.
-      if changed_columns.include?(:hidden) && hidden_origin.nil?
-        if (previous_modification = local_modifications.detect { |mod| mod.type == :visibility })
-          if previous_modification.old_value == hidden?
-            remove_modification(:visibility)
-            return nil
-          end
+      return false unless changed_columns.include?(:hidden) && hidden_origin.nil?
+      if (previous_modification = local_modifications.detect { |mod| mod.type == :visibility })
+        if previous_modification.old_value == hidden?
+          remove_modification(:visibility)
         end
+      else
         append_modification HiddenModification.new(self, current_editor, Time.now, !hidden?, hidden)
       end
+      true
     end
 
     def create_slug_modifications
-      return unless (old_slug = @__slug_changed)
+      change = changes_to_cascade[:slug]
+      return false if change.nil?
+      old_slug, new_slug = change.old_value, self[:slug]
+      return false if old_slug.nil? # ignore first change of slug from nil to provided or generated
       if (previous_modification = local_modifications.detect { |mod| mod.type == :slug })
-        if previous_modification.old_value == self[:slug]
+        if previous_modification.old_value == new_slug
           remove_modification(:slug)
-          return nil
+        else
+          previous_modification.new_value = new_slug
         end
-        previous_modification.new_value = self[:slug]
       else
-        append_modification SlugModification.new(self, current_editor, Time.now, old_slug, self[:slug])
+        append_modification SlugModification.new(self, current_editor, Time.now, old_slug, new_slug)
       end
+      true
     end
 
     def remove_modification(type)
@@ -192,6 +187,12 @@ module Spontaneous::Model::Core
     end
 
     def pending_modifications(filter_type = nil)
+      mods = all_pending_modifications
+      return mods if filter_type.nil?
+      mods.select { |mod| mod.type == filter_type }
+    end
+
+    def all_pending_modifications
       (local_modifications + pieces.flat_map { |piece| piece.local_modifications })
     end
 

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

@@ -17,5 +17,8 @@ module Spontaneous::Model::Core
     def render_using(renderer, format = :html, params = {}, parent_context = nil)
       output(format).render_using(renderer, params, parent_context)
     end
+
+    alias_method :render_inline, :render
+    alias_method :render_inline_using, :render_using
   end
 end

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

@@ -7,15 +7,15 @@ module Spontaneous::Model::Core
     module ClassMethods
       def export(user = nil)
         {
-          :type=> self.ui_class,
-          :id => self.schema_id.to_s,
-          :is_page => self.page?,
-          :is_alias => self.alias?,
-          :title=> self.title,
-          :fields => readable_fields(user).map { |name| field_prototypes[name].export(user) },
-          :styles => readable_styles(user).map { |style| style.export(user) },
-          :boxes => readable_boxes(user).map { |box| box.export(user) },
-          :source => self.__source_file
+          type: ui_class,
+          id: schema_id.to_s,
+          is_page: page?,
+          is_alias: alias?,
+          title: title,
+          fields: readable_fields(user).map { |name| field_prototypes[name].export(user) },
+          styles: readable_styles(user).map { |style| style.export(user) },
+          boxes: readable_boxes(user).map { |box| box.export(user) },
+          source: __source_file
         }
       end
 
@@ -40,14 +40,15 @@ module Spontaneous::Model::Core
     # InstanceMethods
 
     def shallow_export(user)
-      { :id => id,
-        :type => self.class.ui_class,
-        :type_id => self.class.schema_id.to_s,
-        :is_page => page?,
-        :hidden => (hidden? ? true : false),
-        :depth => content_depth,
-        :fields  => fields.export(user),
-        :label => label }
+      { id: id,
+        type: model.ui_class,
+        type_id: model.schema_id.to_s,
+        is_page: page?,
+        page_id: page_id || id,
+        hidden: (hidden? ? true : false),
+        depth: content_depth,
+        fields: fields.export(user),
+        label: label }
     end
 
     def export(user = nil)

data/lib/spontaneous/model/page.rb

@@ -8,6 +8,7 @@ require "spontaneous/model/page/page_tree"
 require "spontaneous/model/page/paths"
 require "spontaneous/model/page/site_map"
 require "spontaneous/model/page/site_timestamps"
+require "spontaneous/model/page/singleton"
 
 module Spontaneous::Model
   module Page
@@ -22,6 +23,8 @@ module Spontaneous::Model
     include SiteMap
     include SiteTimestamps
     include Locks
+    include Singleton
+    include Spontaneous::Model::Core::ContentHash::PageMethods
 
     included do
       many_to_one_content :parent,   :key => :parent_id, :reciprocal => :unordered_children
@@ -37,12 +40,22 @@ module Spontaneous::Model
       end
 
       def export(user = nil)
-        super(user).merge(:title_field => self.title_field.to_s)
+        super(user).merge(title_field: self.title_field_name.to_s)
       end
 
-      def title_field
+      def title_field_name
         :title
       end
+
+      # Use this to cause instances of the class to render as another content object.
+      # Useful if you want say a section to render its first child rather than itself
+      # This method calls #to_page on the result of the block to ensure that the value
+      # returned is a page & not an inline object.
+      def renders(&block)
+        define_method(:renderable) do
+          instance_eval(&block).try(:to_page)
+        end
+      end
     end
 
     def page?
@@ -60,8 +73,9 @@ module Spontaneous::Model
       end
     end
 
-    def children
-      @ordered_children ||= generate_ordered_children(unordered_children)
+    def children(reload = false)
+      @ordered_children = nil if reload
+      @ordered_children ||= generate_ordered_children(unordered_children(reload: reload))
     end
 
     def generate_ordered_children(unordered_children)
@@ -106,7 +120,7 @@ module Spontaneous::Model
     end
 
     def resolve_entry
-      owner.all_contents.find { |e| e.id == self.id }
+      owner.all_contents.wrap_page(self)
     end
 
     def page=(page)
@@ -117,13 +131,13 @@ module Spontaneous::Model
     end
 
     def page_title
-      if field = self.fields[title_field]
+      if field = self.fields[title_field_name]
         field.value
       end
     end
 
-    def title_field
-      self.class.title_field
+    def title_field_name
+      self.class.title_field_name
     end
 
     def shallow_export(user)
@@ -131,6 +145,7 @@ module Spontaneous::Model
         :path => path,
         :title => page_title,
         :slug => slug,
+        :private => in_private_tree?,
         :uid => uid
       })
       hash.delete(:label)
@@ -151,5 +166,17 @@ module Spontaneous::Model
     def eql?(obj)
       super || (Spontaneous::PagePiece === obj && obj.target.eql?(self))
     end
+
+    # Ensure that the *_inline versions of these methods render the entry
+    # (i.e. a PagePiece) not the page instance itself. This avoids a
+    # 'page within page' moment when you try to load a page and then
+    # render it directly within a template.
+    def render_inline(format = :html, params = {}, parent_context = nil)
+      entry.render_inline(format, params, parent_context)
+    end
+
+    def render_inline_using(renderer, format = :html, params = {}, parent_context = nil)
+      entry.render_inline_using(renderer, format, params, parent_context)
+    end
   end
 end

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

@@ -15,10 +15,21 @@ module Spontaneous::Model::Page
     end
 
     # Returns a list of all the pages at a certain depth in the page tree for any page
+    # In the case of pages rooted in a private tree the calculation is done starting from
+    # the public root rather than the root of the tree the page belongs to
     def at_depth(depth, opts = {})
-      return root_at_depth(depth) if is_root?
+      return root_at_depth(depth) if is_public_root? || is_private_root?
       parent_depth = [0, depth - 1].max
-      parent       = ancestor(parent_depth)
+      parent = if (parent_depth == 0)
+        public_root
+      else
+        ancestor(parent_depth)
+      end
+
+      # in the case of page aliases & private roots it's possible for a template
+      # to ask for an ancestor that doesn't exist.
+      return [] if parent.nil?
+
       # This is made more complex because the #children method is unordered
       # whereas the actual page order must come from the boxes
       return parent.children if parent.boxes.empty?
@@ -69,11 +80,12 @@ module Spontaneous::Model::Page
     end
 
     def root_at_depth(depth)
+      root = public_root
       case depth
       when 0
-        self
+        root
       when 1
-        self.children
+        root.children
       else
         raise ArgumentError.new("Cannot calculate descendents of root beyond a depth of 1")
       end
@@ -87,12 +99,12 @@ module Spontaneous::Model::Page
       page.id == self.id or ancestor?(page)
     end
 
-    def generation
-      parent ? parent.children : [root].compact
+    def generation(reload = false)
+      parent ? parent.children(reload) : [root].compact
     end
 
-    def siblings
-      generation.reject { |p| p.id == id }
+    def siblings(reload = false)
+      generation(reload).reject { |p| p.id == id }
     end
 
     def >(page)

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

@@ -13,24 +13,22 @@ module Spontaneous::Model::Page
         /^page-\d{8}-\d{6}$/ === slug
       end
 
-      def create_root(slug)
-        create(slug: slug, :__create_hidden_root =>  true)
+      def create_root(slug, values = {})
+        create(values.merge(slug: slug, :__create_private_root =>  true))
       end
     end
 
     # InstanceMethods
 
-    ANCESTOR_SEP = "."
-
-    def __create_hidden_root=(state)
-      @__is_hidden_root = state
+    def __create_private_root=(state)
+      @__is_private_root = state
     end
 
-    def __create_hidden_root?
-      @__is_hidden_root || false
+    def __create_private_root?
+      @__is_private_root || false
     end
 
-    private :__create_hidden_root=, :__create_hidden_root?
+    private :__create_private_root=, :__create_private_root?
 
     def after_initialize
       super
@@ -39,6 +37,7 @@ module Spontaneous::Model::Page
 
     def before_create
       place_in_page_tree
+      set_slug_from_dynamic_value
       super
     end
 
@@ -69,29 +68,37 @@ module Spontaneous::Model::Page
     # because otherwise the slug would always take on the title fields
     # default value.
     def before_save
-      unless new?
-        if (title = self.fields[title_field])
-          set_slug_from_title(title)
-        end
+      if !new? && (title = fields[title_field_name])
+        set_slug_from_title(title)
       end
       fix_generated_slug_conflicts
       super
     end
 
+    def set_slug_from_dynamic_value
+      if (title = fields[title_field_name]) && title.prototype.dynamic_default?
+        set_slug_from_title!(title)
+      end
+    end
+
     # Syncing the slug with the title is made more difficult because the field
     # update mechanism works differently from the more direct, console version.
     # This is called by the field updater before re-serializing each modified field.
     def before_save_field(field)
-      set_slug_from_title(field) if (field.name == title_field)
+      set_slug_from_title(field) if (field.name == title_field_name)
       super
     end
 
     def set_slug_from_title(title)
       if title.modified? and !title.blank? and has_generated_slug?
-        self.slug = title.value
+        set_slug_from_title!(title)
       end
     end
 
+    def set_slug_from_title!(title)
+      self.slug = title.value
+    end
+
     def sync_slug_to_title
       self.slug = title.unprocessed_value
     end
@@ -100,17 +107,12 @@ module Spontaneous::Model::Page
       self.class.is_default_slug?(slug)
     end
 
-    def after_save
-      super
-      check_for_path_changes
-    end
-
     def generate_default_slug
       self.class.generate_default_slug
     end
 
     def is_conflicting_slug?(slug)
-      siblings.reject { |s| s.root? }.compact.map(&:slug).include?(slug)
+      siblings(true).reject { |s| s.root? }.compact.map(&:slug).include?(slug)
     end
 
     def parent=(parent)
@@ -121,8 +123,8 @@ module Spontaneous::Model::Page
 
     def place_in_page_tree
       if parent_id.nil?
-        if __create_hidden_root? || content_model.has_root?
-          make_hidden_root
+        if __create_private_root? || content_model.has_root?
+          make_private_root
         else
           make_root
         end
@@ -137,33 +139,53 @@ module Spontaneous::Model::Page
       self[:ancestor_path] = ""
     end
 
-    def make_hidden_root
+    def make_private_root
       raise Spontaneous::AnonymousRootException.new if slug.blank?
       self[:path] = "##{slug}"
       self[:ancestor_path] = ""
     end
 
     def ancestor_path
-      (self[:ancestor_path] || "").split(ANCESTOR_SEP).map { |id| id.to_i }
+      (self[:ancestor_path] || "").split(Spontaneous::Model::ANCESTOR_SEP).map { |id| id.to_i }
     end
 
-    def root?
+    def is_public_root?
       path == Spontaneous::SLASH
     end
 
-    alias_method :is_root?, :root?
+    alias_method :root?,    :is_public_root?
+    alias_method :is_root?, :is_public_root?
+
+    # Returns the root of the tree this page belongs to, which in the case
+    # of pages in an private tree will not be the same as the site's
+    # root/home page
+    def tree_root
+      content_model::Page.get(visibility_path_ids.first)
+    end
+
+    def is_private_root?
+      return false unless parent_id.nil?
+      return false if root?
+      path[0] == '#'
+    end
+
+    def in_private_tree?
+      tree_root = self.tree_root
+      return is_private_root? if tree_root.nil?
+      tree_root.is_private_root?
+    end
 
 
     def update_path
       self.path = calculate_path
       if parent
-        self[:ancestor_path] = parent.ancestor_path.push(parent.id).join(ANCESTOR_SEP)
+        self[:ancestor_path] = parent.ancestor_path.push(parent.id).join(Spontaneous::Model::ANCESTOR_SEP)
       end
     end
 
 
     def calculate_path
-      calculate_path_with_slug(self.slug)
+      calculate_path_with_slug(slug)
     end
 
     def calculate_path_with_slug(slug)
@@ -174,12 +196,29 @@ module Spontaneous::Model::Page
       end
     end
 
+    class SlugChange
+      attr_reader :old_value, :new_value
+      def initialize(origin, old_value, new_value)
+        @origin, @old_value, @new_value = origin, old_value, new_value
+      end
+
+      def propagate
+        return if @old_value == @new_value
+        @origin.force_path_changes
+      end
+    end
+
+    included do
+      cascading_change :slug do |origin, old_value, new_value|
+        SlugChange.new(origin, old_value, new_value)
+      end
+    end
+
     # slugs can be max 64 characters long
     def slug=(s)
       if (new_slug = fit_slug_to_length(s, 64)) != slug
-        @__slug_changed = slug
-        self[:slug] = new_slug
-        self.update_path
+        super(new_slug)
+        update_path
       end
     end
 
@@ -195,28 +234,18 @@ module Spontaneous::Model::Page
 
     protected :fit_slug_to_length
 
-    def check_for_path_changes(force = false)
-      if @__slug_changed || force
-        @__slug_changed = false
-        children.each do |child|
-          child.propagate_path_changes
-        end
-        aliases.each do |link|
-          link.propagate_path_changes if link.page?
-        end
-      end
-    end
-
     def force_path_changes
-      check_for_path_changes(true)
+      children.each do |child|
+        child.propagate_path_changes
+      end
+      aliases.each do |link|
+        link.propagate_path_changes if link.page?
+      end
     end
 
     def propagate_path_changes
-      # this happens in the child pages who shouldn't update their modification dates
-      # because updates to paths are handled by modifications held on the origin of the path change
-      @__ignore_page_modification = true
-      self.update_path
-      self.save
+      update_path
+      save
       children.each do |child|
         child.propagate_path_changes
       end