spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/publishing/revision.rb

@@ -0,0 +1,355 @@
+# encoding: UTF-8
+
+module Spontaneous::Publishing
+  class Revision
+    class InvalidRevision < Spontaneous::Error; end
+
+    class Generator
+      # Both revision & source_revision should be instances of Revision
+      def initialize(revision)
+        @revision = revision
+      end
+
+      def run
+        @revision.transaction do
+          create
+        end
+      end
+
+      def create
+        begin
+          create_revision
+          copy_indexes
+          sync_revision
+          set_revision_timestamps
+          set_revision_version
+          @revision.complete
+          @revision.scope do
+            yield if block_given?
+          end
+          set_source_timestamps
+        rescue ::Exception => e
+          @revision.delete
+          raise e
+        end
+      end
+
+      protected
+
+      def create_revision
+        db.run(<<-SQL)
+          CREATE TABLE #{db.literal(@revision.table)}
+            AS #{source_dataset.select_sql}
+        SQL
+      end
+
+      def source_dataset
+        @revision.content_dataset
+      end
+
+      def copy_indexes
+        indexes = db.indexes(@revision.content_table)
+        indexes.each do |name, options|
+          columns = options.delete(:columns)
+          db.add_index(@revision.table, columns, options)
+        end
+      end
+
+      def sync_revision
+        # To be overwritten in Patch subclass
+      end
+
+      def set_revision_timestamps
+        set_timestamps(@revision.dataset)
+      end
+
+      # Update the timestamps on the :content table
+      #
+      # Only do this once we're sure the
+      # publish has completed successfully as they are used
+      # to track which pages need publishing
+      def set_source_timestamps
+        set_timestamps(@revision.content_dataset)
+      end
+
+      def set_timestamps(ds)
+        published_dataset(ds).update({
+          :last_published_at => Sequel.datetime_class.now
+        })
+        first_published_dataset(ds).update({
+          :first_published_at => Sequel.datetime_class.now,
+          :first_published_revision => revision
+        })
+      end
+
+      def published_dataset(ds)
+        ds
+      end
+
+      def first_published_dataset(ds)
+        ds.filter(:first_published_at => nil)
+      end
+
+      def set_revision_version
+        @revision.dataset.update(:revision => revision)
+      end
+
+      def mapper
+        @revision.mapper
+      end
+
+      def db
+        @revision.db
+      end
+
+      def revision
+        @revision.revision
+      end
+    end
+
+    class Patcher < Generator
+      def initialize(revision, modified)
+        super(revision)
+        # pages should be published in depth order because it's
+        # possible to be publishing a child of
+        # a page that's never been published
+        @modified = modified.sort { |m1, m2| m1.depth <=> m2.depth }
+      end
+
+      def source_dataset
+        @revision.previous.history_dataset
+      end
+
+      def sync_revision
+        @modified.each do |m|
+          m.sync_to_revision(revision, true)
+        end
+      end
+
+      def published_dataset(ds)
+        filter_ids(super)
+      end
+
+      def first_published_dataset(ds)
+        filter_ids(super)
+      end
+
+      def filter_ids(ds)
+        ds.filter(:id => @modified.map(&:id))
+      end
+    end
+
+    def self.create(model, revision, &block)
+      new(model, revision).create(&block)
+    end
+
+    def self.patch(model, revision, modified, &block)
+      new(model, revision).patch(modified, &block)
+    end
+
+    def self.exists?(model, revision)
+      new(model, revision).table_exists?
+    end
+
+    def self.delete(model, revision)
+      return if revision.nil?
+      new(model, revision).delete
+    end
+
+    def self.delete_all(model)
+      revisions = tables(model).
+        map { |table| revision_from_table(model, table) }.
+        map { |r| new(model, r) }
+
+      # Don't call the full #delete because it is much more efficient
+      # to delete the contents of the revision tables in a single
+      # command rather than revision by revision
+      revisions.each(&:delete_table)
+      history_dataset(model).delete
+      archive_dataset(model).delete
+    end
+
+    def self.cleanup(model, current_revision, keep_revisions)
+      current = table(model, current_revision)
+      tables = tables(model).reject { |t| t == current }
+      tables.each do |table|
+        model.database.drop_table(table)
+      end
+      history_dataset(model) { revision <= (current_revision - keep_revisions) }.delete
+    end
+
+    def self.history_dataset(model, revision = nil, &block)
+      _filter_dataset(model.mapper.revision_history_dataset, revision, &block)
+    end
+
+    def self.archive_dataset(model, revision = nil, &block)
+      _filter_dataset(model.mapper.revision_archive_dataset, revision, &block)
+    end
+
+    def self._filter_dataset(ds, revision, &block)
+      return ds.filter(&block) if revision.nil?
+      ds.filter(:revision => revision, &block)
+    end
+
+    def self.revision_from_table(model, table)
+      model.mapper.revision_from_table(table)
+    end
+
+    def self.tables(model)
+      mapper = model.mapper
+      model.database.tables.select { |t| mapper.revision_table?(t) }.sort
+    end
+
+    def self.table(model, revision = nil)
+      new(model, revision).table
+    end
+
+    def self.table?(model, table)
+      model.mapper.revision_table?(table)
+    end
+
+    attr_reader :revision
+
+    def initialize(model, revision)
+      @model, @revision = model, revision
+    end
+
+    def create(&block)
+      validate!
+      generator = Generator.new(self)
+      generator.create(&block)
+      self
+    end
+
+    def patch(modified, &block)
+      return create(&block) if must_publish_all?(modified)
+      validate!
+      modified = Array(modified).map { |m|
+        m.is_a?(@model) ? m.reload : @model.get(m)
+      }
+      patcher = Patcher.new(self, modified)
+      patcher.create(&block)
+      self
+    end
+
+    def must_publish_all?(modified)
+      Array(modified).empty? || !previous.revision_exists?
+    end
+
+    def validate!
+      raise InvalidRevision, "Revision '#{@revision.inspect}' is not > 0" if !creatable?
+    end
+
+    def creatable?
+      !@revision.nil? && (@revision > 0)
+    end
+
+    def delete
+      return self unless creatable?
+      delete_table
+      history_dataset.delete
+      archive_dataset.delete
+      self
+    end
+
+    def delete_table
+      database.drop_table?(table)
+    end
+
+    def table_exists?
+      database.tables.include?(table)
+    end
+
+    def revision_exists?
+      return false if @revision.nil?
+      history_dataset.count > 0
+    end
+
+    def exists?
+      revision_exists?
+    end
+
+    def unarchive
+      return if revision_exists?
+      copy_dataset(archive_dataset, history_table)
+    end
+
+    def mapper
+      @model.mapper
+    end
+
+    def database
+      @model.database
+    end
+
+    alias_method :db, :database
+
+    def transaction
+      database.transaction do
+        @model.with_editable do
+          yield
+        end
+      end
+    end
+
+    def scope
+      @model.with_revision(@revision) do
+        yield
+      end
+    end
+
+    def complete
+      copy_to(history_table)
+      copy_to(archive_table)
+    end
+
+    def copy_to(dest_table)
+      copy_dataset(dataset, dest_table)
+    end
+
+    def copy_dataset(ds, dest_table)
+      db.run("INSERT INTO #{db.literal(dest_table)} #{ds.select_sql}")
+    end
+
+    def previous
+      revision = (@revision.nil? || @revision <= 1) ? nil : @revision - 1
+      Revision.new(@model, revision)
+    end
+
+    def table
+      mapper.revision_table(@revision)
+    end
+
+    def dataset
+      db[table]
+    end
+
+    def content_table
+      mapper.base_table
+    end
+
+    def content_dataset
+      db[content_table]
+    end
+
+    def history_table
+      mapper.revision_history_table
+    end
+
+    def history_dataset(&block)
+      _dataset(history_table, &block)
+    end
+
+    def archive_table
+      mapper.revision_archive_table
+    end
+
+    def archive_dataset(&block)
+      _dataset(history_table, &block)
+    end
+
+    def _dataset(table, &block)
+      db[table].filter(:revision => @revision, &block)
+    end
+  end
+end

data/lib/spontaneous/publishing/simultaneous.rb

@@ -1,6 +1,5 @@
 # encoding: UTF-8
 
-require 'simultaneous'
 
 module Spontaneous
   module Publishing
@@ -11,62 +10,24 @@ module Spontaneous
         :publish
       end
 
-      def self.spot_binary
-        ::Spontaneous.config.spontaneous_binary || default_spot_binary
-      end
-
-      def self.default_spot_binary
-        (Pathname.new(Spontaneous.gem_dir) + "bin/spot").expand_path.to_s
-      end
-
       def self.register_task
-        publish_binary = spot_binary + " site publish"
-        site_root = Pathname.new(Spontaneous.root).expand_path.to_s
-        niceness = S.config.publish_niceness || 15
-        logfile =  "#{site_root}/log/publish.log"
-        # TODO: make nice value configurable
+        task = "site publish"
+        niceness = Spontaneous::Site.config.publish_niceness || 15
+        logfile =  "log/publish.log"
         task_options = {
           :niceness => niceness,
-          :logfile => logfile,
-          :pwd => site_root
-        }
-
-        task_params = {
-          "site" => site_root,
-          "logfile" => logfile,
-          "environment" => Spontaneous.env
-        }
-        env = {
-          "SPOT_SERVER" => server_address
+          :logfile  => logfile
         }
-        ::Simultaneous.add_task(task_name, publish_binary, task_options, task_params, env)
+        task_params = {}
+        Spontaneous::Simultaneous.register(task_name, task, task_options, task_params)
       end
 
-      def self.simultaneous_setup
-        ::Simultaneous.client_mode  = :async
-        ::Simultaneous.connection   = ::Spontaneous.config.simultaneous_connection
-        ::Simultaneous.domain       = ::Spontaneous.config.site_domain
-      end
-
-      def self.server_address
-        Spontaneous.config.server_connection || "#{ ::Spontaneous.config.host || "127.0.0.1" }:#{::Spontaneous.config.port}"
-      end
-
-      simultaneous_setup
       register_task
 
-      # def self.status
-      #   FAF.get_status(task_name)
-      # end
-
-      # def self.status=(status)
-      #   FAF.set_status(task_name, status)
-      # end
-
       attr_reader :revision
 
-      def initialize(revision)
-        @revision = revision
+      def initialize(revision, content_model)
+        @revision, @content_model = revision, content_model
       end
 
       def task_name
@@ -74,11 +35,11 @@ module Spontaneous
       end
 
       def publish_pages(page_list)
-        ::Simultaneous.fire(task_name, {"pages" => page_list})
+        Spontaneous::Simultaneous.fire(task_name, {"pages" => page_list})
       end
 
       def publish_all
-        ::Simultaneous.fire(task_name)
+        Spontaneous::Simultaneous.fire(task_name)
       end
     end # Simultaneous
   end # Publishing

data/lib/spontaneous/publishing.rb

@@ -6,6 +6,7 @@ module Spontaneous
     autoload :Threaded,       "spontaneous/publishing/threaded"
     autoload :Simultaneous,   "spontaneous/publishing/simultaneous"
     autoload :EventClient,    "spontaneous/publishing/event_client"
+    autoload :Revision,       "spontaneous/publishing/revision"
   end # Publishing
 end # Spontaneous
 

data/lib/spontaneous/rack/around_back.rb

@@ -10,7 +10,7 @@ module Spontaneous
 
       def call(env)
         response = nil
-        Content.with_identity_map do
+        Spontaneous::Content.scope(nil, false) do
           response = @app.call(env)
         end
         response

data/lib/spontaneous/rack/around_front.rb

@@ -15,10 +15,8 @@ module Spontaneous
       def call(env)
         status = headers = body = nil
         env[Rack::RENDERER] = @renderer
-        Content.with_identity_map do
-          Site.with_published do
-            status, headers, body = @app.call(env)
-          end
+        Spontaneous::Content.with_published do
+          status, headers, body = @app.call(env)
         end
         [status, headers.merge(POWERED_BY), body]
       end

data/lib/spontaneous/rack/around_preview.rb

@@ -12,7 +12,7 @@ module Spontaneous
       def call(env)
         env[Rack::RENDERER] = @renderer
         response = nil
-        Content.with_identity_map do
+        Spontaneous::Content.scope(nil, true) do
           response = @app.call(env)
         end
         response