spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/{plugins → model/core}/publishing.rb

@@ -1,59 +1,77 @@
 # encoding: UTF-8
 
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Publishing
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
-      @@dataset = nil
-      @@revision = nil
 
-      def current_revision_table
-        revision_table(@@revision)
-      end
+      # def current_revision_table
+      #   revision_table(revision)
+      # end
 
-      def base_table
-        'content'
-      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 simple_table
+      #   current_revision_table
+      # end
 
       def revision_table(revision=nil)
-        return base_table if revision.nil?
-        "__r#{revision.to_s.rjust(5, '0')}_content"
+        mapper.revision_table(revision)
       end
 
       def revision_table?(table_name)
-        /^__r\d{5}_content$/ === table_name.to_s
+        mapper.revision_table?(table_name)
       end
 
       def revision_exists?(revision)
-        database.tables.include?(revision_table(revision).to_sym)
+        Spontaneous::Publishing::Revision.exists?(self, revision)
+        # database.tables.include?(revision_table(revision).to_sym)
+      end
+
+      # Returns a list of all tables in the database that represent a content
+      # revision.
+      def revision_tables
+        Spontaneous::Publishing::Revision.tables(self)
+        # database.tables.select { |t| revision_table?(t) }.sort
       end
 
       def revision
-        @@revision
+        mapper.current_revision
       end
 
       def with_revision(revision=nil, &block)
-        saved_revision = @@revision
-        @@revision = revision
-        self.with_table(revision_table(revision), &block)
-      ensure
-        @@revision = saved_revision
+        mapper.revision(revision, &block)
+      end
+
+      def scope(revision = nil, visible = false, &block)
+        mapper.scope(revision, visible, &block)
+      end
+
+      # A version of scope that forces the creation of a new scope
+      # thus allow us to bypass the cache within a particular block
+      def scope!(revision = nil, visible = false, &block)
+        mapper.scope!(revision, visible, &block)
       end
 
       def with_editable(&block)
-        with_revision(nil, &block)
+        mapper.editable(&block)
+      end
+
+      def with_editable!(&block)
+        mapper.editable!(&block)
       end
 
       def with_published(&block)
-        revision = Spontaneous::Site.published_revision
-        with_revision(revision, &block)
+        scope(Spontaneous::Site.published_revision, true, &block)
+      end
+
+      def with_published!(&block)
+        scope!(Spontaneous::Site.published_revision, true, &block)
       end
 
       def database
@@ -67,92 +85,41 @@ module Spontaneous::Plugins
       # rows (taking the rest of the content from the previous revision)
       # Pass in a block if you want to tie some bit of post processing to the success or failure
       # of the publish step (used in the site render stage for example)
-      def publish(revision, content=nil)
-        mark_first_published = Proc.new do |dataset|
-          dataset.update(:first_published_at => Sequel.datetime_class.now, :first_published_revision => revision)
-        end
-
-        mark_published = Proc.new do |dataset|
-          dataset.update(:last_published_at => Sequel.datetime_class.now)
-        end
-
-        first_published = published = nil
-
-        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?))
-
-            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
-
-              # 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 })
-
-              create_revision(revision, revision-1)
-              content.each do |c|
-                c.sync_to_revision(revision, true)
-              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
-              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]
-            end
-          end
-        end
+      def publish(revision, content=nil, &block)
+        Spontaneous::Publishing::Revision.patch(self, revision, content, &block)
       end
 
       def publish_all(revision, &block)
         publish(revision, nil, &block)
       end
 
-      def create_revision(revision, from_revision=nil)
-        dest_table = revision_table(revision)
-        src_table = revision_table(from_revision)
-        sql = "CREATE TABLE #{dataset.quote_identifier(dest_table)} AS SELECT * FROM #{dataset.quote_identifier(src_table)}"
-        database.run(sql)
-        indexes = database.indexes(base_table)
-        indexes.each do |name, options|
-          columns = options.delete(:columns)
-          database.add_index(dest_table, columns, options)
-        end
+      def cleanup_revisions(current_revision, keep_revisions)
+        Spontaneous::Publishing::Revision.cleanup(self, current_revision, keep_revisions)
       end
 
+      # def delete_revision_table(revision)
+      #   return if revision.nil?
+      #   database.drop_table?(revision_table(revision))
+      # end
+
       def delete_revision(revision)
-        return if revision.nil?
-        database.drop_table?(revision_table(revision))
+        Spontaneous::Publishing::Revision.delete(self, revision)
       end
 
       def delete_all_revisions!
-        database.tables.each do |table|
-          database.drop_table(table) if revision_table?(table)
-        end
+        Spontaneous::Publishing::Revision.delete_all(self)
+      end
+
+      # def drop_table(table)
+      #   database.drop_table?(table)
+      # end
+
+      def history_dataset(revision = nil)
+        Spontaneous::Publishing::Revision.history_dataset(self, revision)
+      end
+
+      def archive_dataset(revision = nil)
+        Spontaneous::Publishing::Revision.archive_dataset(self, revision)
       end
     end # ClassMethods
 
@@ -177,6 +144,11 @@ module Spontaneous::Plugins
     def with_revision(revision, &block)
       self.class.with_revision(revision, &block)
     end
+
+    def scope(revision, visible, &block)
+      self.class.scope(revision, visible, &block)
+    end
+
     def with_editable(&block)
       self.class.with_editable(&block)
     end
@@ -196,18 +168,18 @@ module Spontaneous::Plugins
       first_publish = false
 
       with_revision(revision) do
-        published_copy = Spontaneous::Content.first(:id => self.id)
+        published_copy = content_model.get(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.first(:id => entry[0])
+              if c = content_model.get(entry[0])
                 c.destroy(false) rescue ::Sequel::NoExistingObject
               end
             end
           end
         else # missing content (so force a publish)
-          Spontaneous::Content.insert({:id => self.id, :type_sid => values[:type_sid]})
+          content_model.insert({:id => self.id, :type_sid => attributes[:type_sid]})
           publish = true
           first_publish = true
         end
@@ -224,14 +196,14 @@ module Spontaneous::Plugins
             sync_children_to_revision(revision)
           end
 
-          Spontaneous::Content.where(:id => self.id).update(values)
+          content_model.where(:id => self.id).update(attributes)
 
           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])
+            published = self.class.get(self.id)
+            published_values[:path] = published.calculate_path_with_slug(attributes[:slug])
           end
 
           # need to calculate the correct visibility for published items. I can't just take this from the editable
@@ -244,7 +216,7 @@ module Spontaneous::Plugins
           published_values[:hidden] = self.recalculated_hidden unless self.hidden_origin.blank?
 
           unless published_values.empty?
-            Spontaneous::Content.where(:id => self.id).update(published_values)
+            content_model.where(:id => self.id).update(published_values)
           end
 
           # Pages that haven't been published before can be published independently of their parents.
@@ -257,9 +229,9 @@ module Spontaneous::Plugins
     end
 
     def sync_children_to_revision(revision)
-      published_children = with_revision(revision) { S::Content.filter(:parent_id => self.id) }
+      published_children = with_revision(revision) { content_model.filter(:parent_id => self.id) }
       published_children.each do |child_page|
-        deleted = with_editable { S::Content.select(:id).first(:id => child_page.id).nil? }
+        deleted = with_editable { content_model.select(:id).get(child_page.id).nil? }
         if deleted
           with_revision(revision) do
             child_page.destroy
@@ -272,18 +244,24 @@ module Spontaneous::Plugins
     # 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 }
+      return if parent_id.nil?
+      this = self.id
+      detect_entry = proc { |e| e[0] == this }
 
-      parent_entry_store = with_editable { self.parent.entry_store.dup }
+      parent_entry_store = with_editable {
+        content_model[self.parent_id].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 = content_model.get(parent_id)
 
-      published_parent.entry_store ||= []
+      store = published_parent.entry_store || []
 
-      unless published_parent.entry_store.find(&detect_entry)
-        published_parent.entry_store.insert(index, entry).compact!
+      unless store.find(&detect_entry)
+        store.insert(index, entry).compact!
+        published_parent.entry_store = store
       end
+
       published_parent.save
     end
   end

data/lib/spontaneous/{plugins → model/core}/render.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Render
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     def output(format = :html)
       return page.output(format, self) if page

data/lib/spontaneous/{plugins → model/core}/schema_hierarchy.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module SchemaHierarchy
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def schema_validate(schema)
@@ -56,7 +56,7 @@ module Spontaneous::Plugins
       end
 
       def __source_file=(path)
-        @__source_file = path
+        @__source_file ||= path
       end
 
       protected(:__source_file=)
@@ -65,17 +65,13 @@ module Spontaneous::Plugins
         @__source_file
       end
 
-      def subclasses
-        Spontaneous.schema.subclasses_of(self)
-      end
-
-      def descendents
-        Spontaneous.schema.descendents_of(self)
+      def __determine_source_file(subclass, _caller)
+        src = File.expand_path(_caller.split(':')[0])
+        subclass.__source_file = src
       end
 
       def inherited(subclass, real_caller = nil)
-        subclass.__source_file = File.expand_path((real_caller || caller[0]).split(':')[0])
-        Spontaneous.schema.add_class(self, subclass)# if subclass.schema_class?
+        __determine_source_file(subclass, real_caller || caller[0])
         super(subclass)
       end
 

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

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+module Spontaneous::Model::Core
+  module SchemaId
+    extend Spontaneous::Concern
+
+    module ClassMethods
+      def schema_id
+        mapper.schema.to_id(self)
+      end
+
+      def schema_name
+        "type//#{self.name}"
+      end
+
+      def schema_owner
+        nil
+      end
+
+      def owner_sid
+        nil
+      end
+    end # ClassMethods
+
+    # InstanceMethods
+
+    SCHEMA_ID_COLUMNS = [:type, :style, :box]
+    SCHEMA_ID_COLUMNS.each do |c|
+      column = "#{c}_sid"
+      self.class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{column}
+            @_#{column}_sid ||= Spontaneous.schema.uids[super]
+          end
+
+          def #{column}=(sid)
+            @_#{column}_sid = Spontaneous.schema.uids[sid]
+            super(@_#{column}_sid.to_s)
+          end
+      RUBY
+    end
+
+    def refresh
+      SCHEMA_ID_COLUMNS.map { |s| "@_#{s}_sid" }.each do |s|
+        remove_instance_variable(s) if instance_variable_defined?(s)
+      end
+      super
+    end
+
+    def schema_id
+      self.class.schema_id
+    end
+
+    def schema_name
+      self.class.schema_name
+    end
+
+    def schema_owner
+      self.class.schema_owner
+    end
+
+    def owner_sid
+      self.class.owner_sid
+    end
+  end # SchemaId
+end

data/lib/spontaneous/{plugins → model/core}/schema_title.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module SchemaTitle
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def class_name_with_fallback

data/lib/spontaneous/{plugins → model/core}/serialisation.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Serialisation
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def export(user = nil)

data/lib/spontaneous/{plugins → model/core}/styles.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Styles
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def style(name, options={})

data/lib/spontaneous/{plugins → model/core}/supertype.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Supertype
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def supertype

data/lib/spontaneous/{plugins → model/core}/visibility.rb

@@ -1,59 +1,18 @@
 # encoding: UTF-8
 
-module Spontaneous::Plugins
+module Spontaneous::Model::Core
   module Visibility
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
-      @@visible_filter = false
-
-      def _set_visible_dataset!
-        @_saved_dataset ||= self.dataset
-        ds = filter_visible self.dataset
-        @dataset = ds
-        # set_dataset clears the row_proc which desroys the STI
-        # self.set_dataset(ds)
-      end
-
-      def _restore_dataset!
-        # self.set_dataset( self.dataset.unfiltered) if @_saved_dataset
-        @dataset = @_saved_dataset if @_saved_dataset
-        @_saved_dataset = nil
-      end
-
-      def _content_classes
-        [Spontaneous::Content, Spontaneous::Page, Spontaneous::Piece] + Spontaneous.schema.content_classes
-      end
-
-      def _unfiltered_dataset
-        @_saved_dataset or dataset
-      end
-
       def with_visible(&block)
-        if @@visible_filter
+        mapper.visible do
           yield
-        else
-          begin
-            Spontaneous::Content._set_visible_dataset!
-            @@visible_filter = true
-            yield
-          ensure
-            @@visible_filter = false
-            Spontaneous::Content._restore_dataset!
-          end
         end
       end
 
       def visible_only?
-        @@visible_filter
-      end
-
-      def visible
-        filter_visible self.dataset
-      end
-
-      def filter_visible(dataset)
-        dataset.filter(:hidden => false)
+        mapper.visible_only?
       end
     end # ClassMethods
 
@@ -139,7 +98,7 @@ module Spontaneous::Plugins
     end
 
     def hide_aliases(visible)
-      dataset = Spontaneous::Content.filter(:target_id => self.id)
+      dataset = content_model.filter(:target_id => self.id)
       origin = visible ? nil : self.id
       dataset.update(:hidden => !visible, :hidden_origin => origin)
     end
@@ -147,7 +106,7 @@ module Spontaneous::Plugins
     def hide_descendents(visible)
       path_like = :visibility_path.like("#{self[:visibility_path]}.#{self.id}%")
       origin = visible ? nil : self.id
-      dataset = Spontaneous::Content.filter(path_like).filter(:hidden => visible)
+      dataset = content_model.filter(path_like).filter(:hidden => visible)
       # if a child item has been made invisible *before* its parent then it exists
       # with hidden = true and hidden_origin = nil
       if visible
@@ -169,7 +128,7 @@ module Spontaneous::Plugins
 
     def visibility_ancestors
       return [] if visibility_path.blank?
-      visibility_path.split(Spontaneous::VISIBILITY_PATH_SEP).map { |id| S::Content[id] }
+      visibility_path.split(Spontaneous::VISIBILITY_PATH_SEP).map { |id| content_model[id] }
     end
 
     def recalculated_hidden