spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/plugins/entries.rb

@@ -14,7 +14,6 @@ module Spontaneous::Plugins
 
     # InstanceMethods
 
-    VISIBILITY_PATH_SEP = ".".freeze
 
     # because it's possible to build content out of order
     # some relations don't necessarily get created straight away
@@ -31,31 +30,29 @@ module Spontaneous::Plugins
     end
 
     def after_save
-      pieces.each do |entry|
+      contents.each do |entry|
         entry.save if entry.modified?
       end
       super
     end
 
-    def destroy(remove_owner_entry=true, owner=nil)
-      owner ||= self.owner
-      if owner && remove_owner_entry
-        owner.destroy_entry!(self)
-      end
+    def destroy(remove_owner_entry=true, origin = nil)
+      is_origin = origin.nil?
+      origin ||= owner
+      recursive_destroy(origin)
+      origin.child_page_deleted! if (origin && page?)
+      owner = self.owner
+      owner.destroy_entry!(self) if (owner && remove_owner_entry)
       super()
+      origin.after_child_destroy if is_origin && origin
     end
 
-    def before_destroy
-      recursive_destroy
-      super
-    end
-
-    def recursive_destroy
-      all_pieces.destroy
+    def recursive_destroy(origin)
+      all_contents.destroy(origin)
     end
 
     def destroy_entry!(entry)
-      pieces.remove(entry)
+      contents.remove(entry)
       # save the owner because it won't be obvious to the caller
       # that content other than the destroyed object will have been
       # modified
@@ -67,39 +64,42 @@ module Spontaneous::Plugins
     end
 
     def entry_modified!(modified_entry)
-      self.entry_store = all_pieces.serialize_db
+      # 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
 
-    def pieces
-      return visible_pieces if Spontaneous::Content.visible_only?
-      all_pieces
+    def contents
+      return visible_contents if Spontaneous::Content.visible_only?
+      all_contents
     end
 
     # ensure that all access to pieces is through their corresponding entry
     # alias_method :pieces, :entries
 
-    def all_pieces
-      @all_pieces ||= Spontaneous::Collections::EntrySet.new(self, entry_store)
+    def all_contents
+      @all_contents ||= Spontaneous::Collections::EntrySet.new(self, entry_store)
     end
 
-    def visible_pieces
-      @visible_pieces ||= all_pieces.visible!
+    def visible_contents
+      @visible_contents ||= all_contents.visible!
     end
 
-    protected(:all_pieces, :visible_pieces)
+    protected(:all_contents, :visible_contents)
 
     def reload
-      @all_pieces = @visible_pieces = nil
+      @all_contents = @visible_contents = nil
       super
     end
 
 
     def first
-      pieces.first
+      contents.first
     end
 
     def last
-      pieces.last
+      contents.last
     end
 
     def push(page_or_piece)
@@ -139,6 +139,7 @@ module Spontaneous::Plugins
       entry_style = style_for_content(content, box)
       content.box_sid = box.schema_id if box
       content._prototype = box.prototype_for_content(content) if box
+      content.set_visible(self.visible?, self.id)
       content.save if content.new?
       entry = \
         case type
@@ -149,7 +150,7 @@ module Spontaneous::Plugins
         content
       end
       begin
-        pieces.insert(index, box, entry)
+        contents.insert(index, box, entry)
       rescue TypeError, RuntimeError => e
         # TODO: raise a custom more helpful error here
         logger.error { "Attempting to modify visible only pieces" }
@@ -159,6 +160,16 @@ module Spontaneous::Plugins
       entry
     end
 
+    # added is my private mechanism for tracking if a content item is new
+    def before_create
+      @added = true
+      super
+    end
+
+    def added?
+      @added
+    end
+
     def update_position(position)
       entry.set_position(position)
       owner.save
@@ -168,7 +179,7 @@ module Spontaneous::Plugins
       if box
         box.set_position(self, new_position)
       else
-        owner.pieces.set_position(self, new_position)
+        owner.contents.set_position(self, new_position)
       end
     end
 
@@ -186,7 +197,16 @@ module Spontaneous::Plugins
 
     def owner=(owner)
       super
-      self[:visibility_path] = [owner.visibility_path, owner.id].compact.join(VISIBILITY_PATH_SEP)
+      set_visibility_path
+    end
+
+    def set_visibility_path
+      self[:visibility_path] = [owner.visibility_path, owner.id].compact.join(Spontaneous::VISIBILITY_PATH_SEP)
+    end
+
+    def set_visibility_path!
+      set_visibility_path
+      save
     end
   end # Entries
 end # Spontaneous::Plugins

data/lib/spontaneous/plugins/fields.rb

@@ -75,6 +75,21 @@ module Spontaneous::Plugins
       fields.saved
     end
 
+    def before_save
+      save_field_versions
+      super
+    end
+
+    def field_versions(field)
+      Spontaneous::FieldVersion.filter(:content_id => self.id, :field_sid => field.schema_id.to_s).order(:created_at.desc)
+    end
+
+    def save_field_versions
+      fields.each do |field|
+        field.create_version if field.modified?
+      end
+    end
+
     def reload
       @field_set = nil
       super

data/lib/spontaneous/plugins/layouts.rb

@@ -5,8 +5,13 @@ module Spontaneous::Plugins
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def layout(name, options={})
-        layout_prototypes[name] = Spontaneous::Prototypes::LayoutPrototype.new(self, name, options)
+      def layout(name = nil, options = {}, &block)
+        if block_given?
+          @layout_proc = block
+        else
+          raise "Layouts must be given a name" if name.blank?
+          layout_prototypes[name] = Spontaneous::Prototypes::LayoutPrototype.new(self, name, options)
+        end
       end
 
       def layout_prototypes
@@ -24,6 +29,7 @@ module Spontaneous::Plugins
       end
 
       def default_layout
+        return Spontaneous::Layout::Anonymous.new(@layout_proc) unless @layout_proc.nil?
         if prototype = (layouts.hierarchy_detect { |prototype| prototype.default? } || layouts.local_first)
           prototype.layout(self)
         else

data/lib/spontaneous/plugins/modifications.rb

@@ -0,0 +1,228 @@
+module Spontaneous::Plugins
+  # Modifications is responsible for tracking changes made to Content items
+  module Modifications
+    extend ActiveSupport::Concern
+
+    class SlugModification
+      def self.type
+        :slug
+      end
+
+      attr_reader :owner, :user, :created_at, :old_value, :new_value
+
+      def initialize(owner, user, created_at, old_value, new_value)
+        @owner, @user, @created_at, @old_value, @new_value = owner, user, created_at, old_value, new_value
+        @created_at = Time.parse(created_at) if @created_at.is_a?(String)
+        @user = Spontaneous::Permissions::User[user] if @user.is_a?(Fixnum)
+      end
+
+      # Must apply this change the slow way by cascading updates from the parent because
+      # otherwise it's difficult to publish changes to a child page's slug and publish them
+      # separately
+      def apply(revision)
+        owner.with_revision(revision) do
+          owner.force_path_changes
+        end
+      end
+
+      def dataset
+        path_like = :ancestor_path.like("#{owner[:ancestor_path]}.#{owner.id}%")
+        Spontaneous::Content.filter(path_like)
+      end
+
+      def count
+        dataset.count
+      end
+
+      def serialize
+        [type, user_id, created_at.to_s(:rfc822), old_value, new_value]
+      end
+
+      def user_id
+        @user.nil? ? nil : @user.id
+      end
+
+      def type
+        self.class.type
+      end
+
+      def ==(other)
+        super || (other.class == self.class &&
+                  other.owner.id == self.owner.id &&
+                  other.old_value == self.old_value &&
+                  other.new_value == self.new_value)
+      end
+
+      def new_value=(value)
+        @created_at = Time.now
+        @new_value = value
+      end
+
+      def inspect
+        %(#<#{self.class}:#{self.object_id.to_s(16)} owner="#{owner.id}" old_value=#{old_value.inspect} new_value=#{new_value.inspect}>)
+      end
+    end
+
+    class HiddenModification < SlugModification
+      def self.type
+        :visibility
+      end
+
+      def apply(revision)
+        owner.with_revision(revision) do
+          published = Spontaneous::Content.first :id => owner.id
+          published.set_visible_with_cascade!(!new_value)
+        end
+      end
+
+      def dataset
+        path_like = :visibility_path.like("#{owner[:visibility_path]}.#{owner.id}%")
+        Spontaneous::Page.filter(path_like)
+      end
+    end
+
+    class DeletionModification < SlugModification
+      def self.type
+        :deletion
+      end
+
+      def apply(revision)
+        # Deletion modifications are handled higher up the publish chain.
+        # The modification objects are merely for informational purposes.
+      end
+
+      def count
+        old_value - new_value
+      end
+    end
+
+    def current_editor
+      @current_editor
+    end
+
+    def current_editor=(user)
+      @current_editor = user
+    end
+
+    def reload
+      @local_modifications = nil
+      super
+    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?
+      # 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
+      generate_modification_list
+      super
+    end
+
+    def after_publish(revision)
+      pending_modifications.each do |modification|
+        modification.apply(revision)
+      end
+      with_editable { clear_pending_modifications! }
+      with_revision(revision) { clear_pending_modifications! }
+      super
+    end
+
+    def generate_modification_list
+      create_slug_modifications
+      create_visibility_modifications
+      serialize_pending_modifications
+    end
+
+    def child_page_deleted!
+      @child_page_deletion_count ||= 0
+      @child_page_deletion_count += 1
+    end
+
+    def after_child_destroy
+      create_deletion_modifications && serialize_pending_modifications
+      save
+    end
+
+    def create_deletion_modifications
+      if @child_page_deletion_count && @child_page_deletion_count > 0
+        count = S::Page.count
+        append_modification DeletionModification.new(self, current_editor, Time.now, count + @child_page_deletion_count, count)
+      end
+    end
+
+    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
+        end
+        append_modification HiddenModification.new(self, current_editor, Time.now, !hidden?, hidden)
+      end
+    end
+
+    def create_slug_modifications
+      return unless (old_slug = @__slug_changed)
+      if (previous_modification = local_modifications.detect { |mod| mod.type == :slug })
+        if previous_modification.old_value == self[:slug]
+          remove_modification(:slug)
+          return nil
+        end
+        previous_modification.new_value = self[:slug]
+      else
+        append_modification SlugModification.new(self, current_editor, Time.now, old_slug, self[:slug])
+      end
+    end
+
+    def remove_modification(type)
+      local_modifications.delete_if { |mod| mod.type == type }
+    end
+
+    def append_modification(modification)
+      local_modifications.push modification
+    end
+
+    def pending_modifications(filter_type = nil)
+      (local_modifications + pieces.flat_map { |piece| piece.local_modifications })
+    end
+
+    def clear_pending_modifications!
+      self.serialized_modifications = nil
+      self.class.filter(:id => self.id).update(:serialized_modifications => "[]")
+      @local_modifications = nil
+      pieces.each do |piece|
+        piece.clear_pending_modifications!
+      end
+    end
+
+    def serialize_pending_modifications
+      self.serialized_modifications = local_modifications.map { |modification| modification.serialize }
+    end
+
+    def local_modifications
+      @local_modifications ||= deserialize_local_modifications
+    end
+
+    def deserialize_local_modifications
+      values = self.serialized_modifications || []
+      class_map = modification_class_map
+      values.map do |(type, *values)|
+        type = type.to_sym
+        args = [self, *values]
+        class_map[type].new(*args)
+      end
+    end
+
+    def modification_class_map
+      Hash[[SlugModification, HiddenModification, DeletionModification].map { |mod_class| [mod_class.type, mod_class] }]
+    end
+  end
+end

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

@@ -7,86 +7,111 @@ module Spontaneous::Plugins::Page
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def formats(*formats)
-        return format_list if formats.nil? or formats.empty?
-        set_formats(formats)
+      def outputs(*outputs)
+        return output_list if outputs.nil? or outputs.empty?
+        set_outputs(outputs)
       end
 
-      def format_list
-        @formats ||= supertype_formats
+      def output_map
+        @outputs ||= supertype_outputs
       end
 
-      def mime_types
-        @mime_types ||= supertype_mimetypes
+      def output_list
+        output_map.values
       end
 
-      def add_format(new_format)
-        format = define_format(new_format)
-        format_list.push(format)
+      def add_output(format, *args)
+        options = args.extract_options!
+        output = define_and_add_output(format, options)
       end
 
-      def set_formats(formats)
-        formats = formats.flatten
-        mime_types.clear
-        format_list.clear
-        formats.map do |format|
-          format_list.push define_format(format)
+      def set_outputs(outputs)
+        output_map.clear
+        outputs.each do |definition|
+          define_and_add_output(*definition)
         end
       end
 
-      def define_format(format)
-        mime_type = nil
-        if format.is_a?(Hash)
-          mime_type = format.values.first
-          format = format.keys.first
-          mime_types[format.to_sym] = mime_type
-        else
-          mime_type = ::Rack::Mime.mime_type(".#{format}", nil)
+      def define_and_add_output(format, options = {})
+        output = define_output(format, options)
+        output_map[output.name] = output
+      end
+
+      def define_output(format, options = {})
+        o = Spontaneous::Output.create(format, options).tap do |output|
+          silence_warnings { self.const_set("Output#{format.to_s.upcase}", output) }
         end
-        raise Spontaneous::UnknownFormatException.new(format) unless mime_type
-        format.to_sym
       end
 
-      def supertype_formats
-        supertype? && supertype.respond_to?(:formats) ? supertype.formats.dup : [:html]
+      def supertype_outputs
+        supertype? && supertype.respond_to?(:outputs) ? supertype.output_map.dup : { :html => standard_output }
       end
 
-      def supertype_mimetypes
-        supertype? && supertype.respond_to?(:mime_types) ? supertype.mime_types.dup : {}
+      def standard_output
+        define_output(:html)
       end
 
-      def default_format
-        formats.first
+      def default_output
+        output_list.first
       end
 
       def provides_format?(format)
-        format = (format || :html).to_sym
-        formats.include?(format)
+        return true if format.blank?
+        format = format.to_s
+        outputs.any? { |output| (output == format) or (output.name.to_s == format) }
+      end
+
+      alias_method :provides_output?, :provides_format?
+
+      def output(name = nil)
+        output_without_validation(name) or raise Spontaneous::UnknownOutputException.new(self, name)
+      end
+
+      def output_without_validation(name = nil)
+        return name if name.is_a?(Spontaneous::Output::Format)
+        return default_output if name.blank?
+        output_map[name.to_sym]
       end
 
       def mime_type(format)
-        if mime_types && mime_types.key?(format)
-          mime_types[format]
+        return format.mime_type if format.respond_to?(:mime_type)
+        if (match = output_without_validation(format))
+          match.mime_type
         else
           ::Rack::Mime.mime_type(".#{format}")
         end
       end
     end # ClassMethods
 
-    def formats
-      self.class.formats
+    def outputs
+      self.class.outputs.map { |output| output.new(self) }
+    end
+
+    def default_output
+      self.class.default_output.new(self)
     end
 
-    def default_format
-      self.class.default_format
+    def provides_output?(format)
+      self.class.provides_output?(format)
     end
 
-    def provides_format?(format)
-      self.class.provides_format?(format)
+    def output(format, content = nil)
+      return format if format.is_a?(Spontaneous::Output::Format)
+      output_class = self.class.output(format)
+      output_class.new(self, content)
     end
 
     def mime_type(format)
       self.class.mime_type(format)
     end
+
+    def render(format=:html, params={}, *args)
+      if format.is_a?(Hash)
+        params = format
+        format = :html
+      end
+      output = output(format)
+      output.render(params, *args)
+    end
   end # Formats
 end # Spontaneous::Plugins::Page

data/lib/spontaneous/plugins/page/request.rb

@@ -63,10 +63,20 @@ module Spontaneous::Plugins::Page
         @request_blocks ||= {}
       end
 
+
+      METHOD_MAP = {"GET" => :get, "POST" => :post, "PUT" => :put, "DELETE" => :delete, "HEAD" => :head }.freeze
+
+      # Translate Rack's uppercase string methods to the symbols used internally
+      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)
         request_blocks.has_key?(method) && !request_blocks[method].nil?
       end
 

data/lib/spontaneous/plugins/page/site_timestamps.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+require 'rack'
+
+module Spontaneous::Plugins::Page
+  module SiteTimestamps
+    extend ActiveSupport::Concern
+
+    def after_update
+      ::Spontaneous::State.site_modified! if field?(title_field) && fields[title_field].modified?
+      super
+    end
+
+    # Update the Site's modification time to force clients
+    # to reload their map data
+    def after_create
+      ::Spontaneous::State.site_modified!
+      super
+    end
+
+    # Update the Site's modification time to force clients
+    # to reload their map data
+    def after_destroy
+      ::Spontaneous::State.site_modified!
+      super
+    end
+  end
+end

data/lib/spontaneous/plugins/paths.rb

@@ -50,6 +50,7 @@ module Spontaneous::Plugins
 
     def parent=(parent)
       @__parent_changed = true
+      update_path
       super
     end
 
@@ -91,6 +92,10 @@ module Spontaneous::Plugins
 
 
     def calculate_path
+      calculate_path_with_slug(self.slug)
+    end
+
+    def calculate_path_with_slug(slug)
       if parent.nil?
         root? ? Spontaneous::SLASH : '' # bad case, no parent but not root
       else
@@ -100,15 +105,15 @@ module Spontaneous::Plugins
 
     def slug=(s)
       if (new_slug = s.to_url) != self.slug
-        @__slug_changed = true
+        @__slug_changed = self.slug
         # slugs can be max 255 characters long
         self[:slug] = new_slug[0..254]
         self.update_path
       end
     end
 
-    def check_for_path_changes
-      if @__slug_changed
+    def check_for_path_changes(force = false)
+      if @__slug_changed || force
         @__slug_changed = false
         children.each do |child|
           child.propagate_path_changes
@@ -119,7 +124,14 @@ module Spontaneous::Plugins
       end
     end
 
+    def force_path_changes
+      check_for_path_changes(true)
+    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
       children.each do |child|