spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/plugins/publishing.rb

@@ -75,48 +75,55 @@ module Spontaneous::Plugins
         mark_published = Proc.new do |dataset|
           dataset.update(:last_published_at => Sequel.datetime_class.now)
         end
+
         first_published = published = nil
 
-        with_editable do
-          first_published = self.filter(:first_published_at => nil)
-          published = self.filter
+        db.transaction do
+          with_editable do
+            first_published = self.filter(:first_published_at => nil)
+            published = self.filter
+
+            must_publish_all = (content.nil? || (!revision_exists?(revision-1)) || \
+                                (content.is_a?(Array) && content.empty?))
 
-          must_publish_all = (content.nil? || (!revision_exists?(revision-1)) || \
-                              (content.is_a?(Array) && content.empty?))
+            if must_publish_all
+              create_revision(revision)
+            else
+              content = content.map do |c|
+                c.is_a?(Spontaneous::Content) ? c.reload : Spontaneous::Content.first(:id => c)
+              end.compact
 
-          if must_publish_all
-            create_revision(revision)
-          else
-            content = content.map do |c|
-              c.is_a?(Spontaneous::Content) ? c.reload : Spontaneous::Content[c]
-            end.compact
+              # pages should be published in depth order because its possible to be publishing a child of
+              # a page that's never been published
+              content.sort! { |c1, c2| c1.depth <=> c2.depth }
 
-            first_published = first_published.filter(:id => content.map { |c| c.id })
-            published = published.filter(:id => content.map { |c| c.id })
+              first_published = first_published.filter(:id => content.map { |c| c.id })
+              published = published.filter(:id => content.map { |c| c.id })
 
-            create_revision(revision, revision-1)
-            content.each do |c|
-              c.sync_to_revision(revision)
+              create_revision(revision, revision-1)
+              content.each do |c|
+                c.sync_to_revision(revision, true)
+              end
             end
-          end
 
-          # run any passed code and if it fails revert the publish step
-          if block_given?
-            begin
-              with_revision(revision) { yield }
-            rescue Exception => e
-              delete_revision(revision)
-              raise e
+            # run any passed code and if it fails revert the publish step
+            if block_given?
+              begin
+                with_revision(revision) { yield }
+              rescue Exception => e
+                delete_revision(revision)
+                raise e
+              end
             end
-          end
 
-          with_editable do
-            mark_first_published[first_published]
-            mark_published[published]
-          end
-          with_revision(revision) do
-            mark_first_published[first_published]
-            mark_published[published]
+            with_editable do
+              mark_first_published[first_published]
+              mark_published[published]
+            end
+            with_revision(revision) do
+              mark_first_published[first_published]
+              mark_published[published]
+            end
           end
         end
       end
@@ -139,7 +146,7 @@ module Spontaneous::Plugins
 
       def delete_revision(revision)
         return if revision.nil?
-        database.drop_table(revision_table(revision)) if revision_exists?(revision)
+        database.drop_table?(revision_table(revision))
       end
 
       def delete_all_revisions!
@@ -151,6 +158,11 @@ module Spontaneous::Plugins
 
     # InstanceMethods
 
+    def after_create
+      super
+      page.modified!(page?) if page
+    end
+
     def after_update
       super
       page.modified!(page?) if page
@@ -160,14 +172,8 @@ module Spontaneous::Plugins
       unless caller_is_page
         self.model.where(:id => self.id).update(:modified_at => Sequel.datetime_class.now)
       end
-      push_page_change
     end
 
-    def push_page_change
-      Spontaneous::Change.push(self) if page?
-    end
-
-
     def with_revision(revision, &block)
       self.class.with_revision(revision, &block)
     end
@@ -175,37 +181,110 @@ module Spontaneous::Plugins
       self.class.with_editable(&block)
     end
 
-    def sync_to_revision(revision, origin=true)
+    def never_published?
+      first_published_at.nil?
+    end
+
+    def before_publish(revision); end
+    def after_publish(revision);  end
+
+    def sync_to_revision(revision, origin=false)
       # 'publish' is a lock to make sure the duplication doesn't cross
       # page boundaries unless that's necessary (such as in the case
       # of a page addition)
       publish = origin || !self.page?
+      first_publish = false
 
       with_revision(revision) do
-        published_copy = Spontaneous::Content[self.id]
+        published_copy = Spontaneous::Content.first(:id => self.id)
         if published_copy
           if publish and published_copy.entry_store
             pieces_to_delete = published_copy.entry_store - self.entry_store
             pieces_to_delete.each do |entry|
-              if c = Spontaneous::Content[entry[0]]
-                c.destroy(false)
+              if c = Spontaneous::Content.first(:id => entry[0])
+                c.destroy(false) rescue ::Sequel::NoExistingObject
               end
             end
           end
         else # missing content (so force a publish)
-          Spontaneous::Content.insert({:id => self.id})
+          Spontaneous::Content.insert({:id => self.id, :type_sid => values[:type_sid]})
           publish = true
+          first_publish = true
         end
 
         if publish
+          self.before_publish(revision)
           with_editable do
             self.pieces.each do |entry|
               entry.sync_to_revision(revision, false)
             end
           end
-          Spontaneous::Content.where(:id => self.id).update(self.values)
+
+          if self.page?
+            sync_children_to_revision(revision)
+          end
+
+          Spontaneous::Content.where(:id => self.id).update(values)
+
+          published_values = {}
+          # ancestors can have un-published changes to their paths so we can't just directly publish the current path.
+          # Instead we re-calculate our path using the published version of the ancestor's path & our (potentially) updated slug.
+          if self.page?
+            published = self.class.first :id => self.id
+            published_values[:path] = published.calculate_path_with_slug(values[:slug])
+          end
+
+          # need to calculate the correct visibility for published items. I can't just take this from the editable
+          # content because up-tree visibility changes might not have been published. This kinda mess is why individual
+          # page publishing is a pain.
+          # However, this only applies if the item's visibility is dependent on some up-tree state. So
+          # if hidden_origin is empty (which means we have a separately calculated visibility) we want
+          # to take visibility from our own value.
+
+          published_values[:hidden] = self.recalculated_hidden unless self.hidden_origin.blank?
+
+          unless published_values.empty?
+            Spontaneous::Content.where(:id => self.id).update(published_values)
+          end
+
+          # Pages that haven't been published before can be published independently of their parents.
+          # In that case we need to insert an entry for them. We can't guarantee that the published
+          # parent has the same entries
+          insert_entry_for_new_page(revision) if first_publish && page?
+          self.after_publish(revision)
+        end
+      end
+    end
+
+    def sync_children_to_revision(revision)
+      published_children = with_revision(revision) { S::Content.filter(:parent_id => self.id) }
+      published_children.each do |child_page|
+        deleted = with_editable { S::Content.select(:id).first(:id => child_page.id).nil? }
+        if deleted
+          with_revision(revision) do
+            child_page.destroy
+          end
         end
       end
     end
+
+    # Finds an entry in the parent page and duplicates it to the parent
+    # of the newly published page. Positions are not exact as other child pages might not have
+    # been published.
+    def insert_entry_for_new_page(revision)
+      detect_entry = proc { |e| e[0] == self.id }
+
+      parent_entry_store = with_editable { self.parent.entry_store.dup }
+      entry = parent_entry_store.find(&detect_entry)
+      index = parent_entry_store.index(&detect_entry)
+      published_parent = Spontaneous::Content.first :id => parent_id
+
+      published_parent.entry_store ||= []
+
+      unless published_parent.entry_store.find(&detect_entry)
+        published_parent.entry_store.insert(index, entry).compact!
+      end
+      published_parent.save
+    end
   end
 end

data/lib/spontaneous/plugins/render.rb

@@ -4,13 +4,18 @@ module Spontaneous::Plugins
   module Render
     extend ActiveSupport::Concern
 
-    # InstanceMethods
-    def render(format=:html, params={}, *args)
-      if format.is_a?(Hash)
-        params = format
-        format = :html
-      end
-      Spontaneous::Render.render(self, format, params, *args)
+    def output(format = :html)
+      return page.output(format, self) if page
+      raise "Cannot render content without enclosing page"
     end
-  end # Render
+
+    def render(format = :html, params = {}, *args)
+      params, format = format, :html if format.is_a?(Hash)
+      output(format).render(params, *args)
+    end
+
+    def render_using(renderer, format = :html, params = {}, *args)
+      output(format).render_using(renderer, params, *args)
+    end
+  end
 end

data/lib/spontaneous/plugins/schema_hierarchy.rb

@@ -5,37 +5,49 @@ module Spontaneous::Plugins
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def schema_validate
+      def schema_validate(schema)
         if schema_id.nil?
-          Spontaneous.schema.missing_id!(:type, self)
+          schema.missing_id!(:type, self)
         else
           # only need to check internal consistency if class already existed
           fields.each do |field|
             if field.owner == self and field.schema_id.nil?
-              Spontaneous.schema.missing_id!(:field, field)
+              schema.missing_id!(:field, field)
             end
           end
           # boxes don't have boxes
           if respond_to?(:boxes)
             boxes.each do |box|
               if box.owner == self and box.schema_id.nil?
-                Spontaneous.schema.missing_id!(:box, box)
+                schema.missing_id!(:box, box)
               end
             end
           end
 
           styles.each do |style|
             if style.owner == self and style.schema_id.nil?
-              Spontaneous.schema.missing_id!(:style, style)
+              schema.missing_id!(:style, style)
             end
           end
           if respond_to?(:layouts)
             layouts.each do |layout|
               if layout.owner == self and layout.schema_id.nil?
-                Spontaneous.schema.missing_id!(:layout, layout)
+                schema.missing_id!(:layout, layout)
               end
             end
           end
+          # Group memberships can get out of sync if a class is modified
+          # but their details are transient & not stored in the map so
+          # we don't need to raise any errors and can fix things auto-
+          # matically.
+          if respond_to?(:group_memberships)
+            type_memberships = group_memberships || []
+            schema_memberships = schema.group_memberships(self)
+            if type_memberships != schema_memberships
+              schema.remove_group_members(self)
+              schema.add_group_member(self, type_memberships)
+            end
+          end
         end
       end
 

data/lib/spontaneous/plugins/site/helpers.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins::Site
+  module Helpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def helper(*formats, &block)
+        helper_module = Module.new(&block)
+        register_helper(helper_module, *formats.flatten)
+        helper_module
+      end
+
+      # Private: Generates a module including all helper methods for the requested format(s)
+      def context(*formats)
+        formats = [:*].concat formats.flatten.map { |f| f.to_sym }
+        helper_module = Module.new
+        formats.each do |format|
+          Spontaneous::Output::Helpers.registered_helpers[format].each do |mod|
+            helper_module.send :include, mod
+            helper_module.send :extend,  mod
+          end
+          Spontaneous::Site.registered_helpers[format].each do |mod|
+            helper_module.send :include, mod
+            helper_module.send :extend,  mod
+          end
+        end
+        helper_module
+      end
+
+      def register_helper(helper_module, *formats)
+        site = instance
+        if formats.empty?
+          site.registered_helpers[:*] << helper_module
+        else
+          formats.each do |format|
+            site.registered_helpers[format.to_sym] << helper_module
+          end
+        end
+      end
+
+      def registered_helpers
+        instance.registered_helpers
+      end
+    end
+
+    def registered_helpers
+      @registered_helpers ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+  end # Helpers
+end
+

data/lib/spontaneous/plugins/site/hooks.rb

@@ -0,0 +1,50 @@
+
+module Spontaneous::Plugins::Site
+  module Hooks
+    extend ActiveSupport::Concern
+
+    HOOKS = [:after_publish]
+
+    module ClassMethods
+      HOOKS.each do |hook|
+        # def after_publish(&block)
+        #   instance.after_publish(&block)
+        # end
+        class_eval(<<-RB)
+          def #{hook}(&block)
+            instance.#{hook}(&block)
+          end
+        RB
+      end
+
+      def trigger(event_name, *args)
+        instance.trigger(event_name, *args)
+      end
+    end
+
+    HOOKS.each do |hook|
+      # def after_publish(&block)
+      #   add_trigger(:after_publish, block)
+      # end
+      class_eval(<<-RB)
+        def #{hook}(&block)
+          add_trigger(:#{hook}, block)
+        end
+      RB
+    end
+
+    def triggers
+      @triggers ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def add_trigger(trigger_name, block)
+      triggers[trigger_name] << block
+    end
+
+    def trigger(event_name, *args)
+      triggers[event_name].each do |block|
+        block.call(*args)
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/site/map.rb

@@ -10,7 +10,7 @@ module Spontaneous::Plugins::Site
           if root_id.nil?
             Spontaneous::Page.root
           else
-            Spontaneous::Content[root_id]
+            Spontaneous::Content.first :id => root_id
           end
         return nil unless page
         page.map_entry

data/lib/spontaneous/plugins/site/paths.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Site
+  module Paths
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def paths(group)
+        instance.facets.flat_map { |facet| facet.paths.expanded(group) }
+      end
+    end # ClassMethods
+  end # Paths
+end

data/lib/spontaneous/plugins/site/publishing.rb

@@ -27,14 +27,18 @@ module Spontaneous::Plugins::Site
         end
       end
 
-      def publish_changes(change_list=nil)
-        publishing_method.new(self.revision).publish_changes(change_list)
+      def publish_pages(page_list=nil)
+        publishing_method.new(self.revision).publish_pages(page_list)
       end
 
       def publish_all
         publishing_method.new(self.revision).publish_all
       end
 
+      def rerender
+        publishing_method.new(self.published_revision).rerender_revision
+      end
+
       def publishing_status
         status = rest = nil
         # if r = S::Site.pending_revision

data/lib/spontaneous/plugins/site/{revisions.rb → state.rb}

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 module Spontaneous::Plugins::Site
-  module Revisions
+  module State
     extend ActiveSupport::Concern
 
     module ClassMethods
@@ -21,6 +21,10 @@ module Spontaneous::Plugins::Site
         Spontaneous::State.pending_revision
       end
 
+      def modified_at
+        Spontaneous::State.modified_at
+      end
+
       def revision_root(*path)
         instance.revision_root(*path)
       end

data/lib/spontaneous/plugins/site/storage.rb

@@ -28,6 +28,10 @@ module Spontaneous::Plugins::Site
       def local_storage
         instance.local_storage
       end
+
+      def default_storage
+        instance.default_storage
+      end
     end # ClassMethods
 
     def storage(mimetype = nil)

data/lib/spontaneous/plugins/site/url.rb

@@ -0,0 +1,15 @@
+module Spontaneous::Plugins::Site
+  module URL
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def public_url(path = "/")
+        instance.public_url(path)
+      end
+    end
+
+    def public_url(path = "/")
+      "http://%s%s" % [ config.site_domain, path ]
+    end
+  end
+end

data/lib/spontaneous/plugins/site_map.rb

@@ -11,11 +11,21 @@ module Spontaneous::Plugins
 
     def map_entry
       shallow_map_entry.merge({
-        :children => self.children.map {|c| c.shallow_map_entry },
-        :generation => self.generation.map {|c| c.shallow_map_entry },
-        :ancestors => self.ancestors.map {|c| c.shallow_map_entry },
+        :children => grouped_page_list(self.children),
+        :generation => grouped_page_list(self.generation),
+        :ancestors => self.ancestors.map {|c| c.shallow_map_entry }
       })
     end
+
+    def grouped_page_list(pages)
+      Hash.new { |hash, key| hash[key] = [] }.tap { |map|
+        pages.each do |p|
+          return {:Root => [p.shallow_map_entry]} if p.container.nil? # guard for site root
+          map[p.container._prototype.title] << p.shallow_map_entry
+        end
+      }
+    end
+
     def shallow_map_entry
       {
         :id => id,

data/lib/spontaneous/plugins/styles.rb

@@ -64,7 +64,11 @@ module Spontaneous::Plugins
     # InstanceMethods
 
     def style=(style)
-      self.style_sid = style_to_schema_id(style)
+      self[:style_sid] = style_to_schema_id(style).to_s
+    end
+
+    def style_sid
+      self[:style_sid]
     end
 
     # converts a symbol or string into a Schema::UID instance

data/lib/spontaneous/plugins/visibility.rb

@@ -9,7 +9,7 @@ module Spontaneous::Plugins
 
       def _set_visible_dataset!
         @_saved_dataset ||= self.dataset
-        ds = self.dataset.filter(:hidden => false)
+        ds = filter_visible self.dataset
         @dataset = ds
         # set_dataset clears the row_proc which desroys the STI
         # self.set_dataset(ds)
@@ -49,18 +49,22 @@ module Spontaneous::Plugins
       end
 
       def visible
-        self.dataset.filter(:hidden => false)
+        filter_visible self.dataset
+      end
+
+      def filter_visible(dataset)
+        dataset.filter(:hidden => false)
       end
     end # ClassMethods
 
     # InstanceMethods
 
     def visible?
-      !self.hidden
+      !self.hidden?
     end
 
     def hidden?
-      self.hidden
+      self.hidden || false
     end
 
     def hide!
@@ -92,34 +96,48 @@ module Spontaneous::Plugins
       set_visible(visible)
     end
 
-
-    protected
-
     def set_visible!(state)
       self.set_visible(state)
       self.save
       self
     end
 
-    def set_visible(visible)
+    # Private: Used by visibility modifications to force a cascade of visibility
+    # state during the publish process.
+    def set_visible_with_cascade!(state)
+      set_visible(state)
+      force_visibility_cascade
+      self.save
+      self
+    end
+
+    def set_visible(visible, hidden_origin = nil)
       protect_root_visibility!
       if self.visible? != visible
         raise Spontaneous::NotShowable.new(self, hidden_origin) if hidden? && visible && !showable?
         self[:hidden] = !visible
-        self[:hidden_origin] = nil
-        @_visibility_modified = true
+        self[:hidden_origin] = hidden_origin
+        force_visibility_cascade
       end
     end
 
+    def force_visibility_cascade
+      @_visibility_modified = true
+    end
+
     def after_save
       super
       if @_visibility_modified
-        hide_descendents(self.visible?)
-        hide_aliases(self.visible?)
+        propagate_visibility_state
         @_visibility_modified = false
       end
     end
 
+    def propagate_visibility_state
+      hide_descendents(self.visible?)
+      hide_aliases(self.visible?)
+    end
+
     def hide_aliases(visible)
       dataset = Spontaneous::Content.filter(:target_id => self.id)
       origin = visible ? nil : self.id
@@ -149,6 +167,15 @@ module Spontaneous::Plugins
       # Spontaneous::Content.from(:content___n, :content___p).filter(path_like).filter(:n__page_id => :p__id).set(:n__visible => visible, :n__hidden_origin => origin)
     end
 
+    def visibility_ancestors
+      return [] if visibility_path.blank?
+      visibility_path.split(Spontaneous::VISIBILITY_PATH_SEP).map { |id| S::Content[id] }
+    end
+
+    def recalculated_hidden
+      visibility_ancestors.any? { |ancestor| ancestor.hidden? }
+    end
+
     def protect_root_visibility!
       if self.is_page? && self.is_root?
         raise "Root page is not hidable"

data/lib/spontaneous/prototypes/box_prototype.rb

@@ -171,6 +171,10 @@ module Spontaneous::Prototypes
       instance_class.readable_fields(user)
     end
 
+    def allow(*args)
+      instance_class.allow(*args)
+    end
+
     def allowed_types(user)
       if writable?(user)
         types = []