spontaneous 0.2.0.beta5 → 0.2.0.beta6

data/lib/spontaneous/publishing/progress.rb

@@ -0,0 +1,186 @@
+require 'logger'
+require 'delegate'
+require 'simultaneous'
+
+module Spontaneous::Publishing
+  module Progress
+    class Duration < DelegateClass(Float)
+      def to_s
+        d = self.to_f
+        h, r = _factor(d, 3600)
+        m, _ = _factor(r, 60)
+        s = (d - (h*3600 + m * 60)).round(2)
+        "%02dh %02dm %02.2fs" % [h, m,s]
+      end
+
+      def _factor(d, f)
+        [d.to_i/f, d.to_i%f]
+      end
+    end
+
+    def self.registered
+      @registered ||= {}
+    end
+
+    class Progress
+      def self.register(klass, *names)
+        names.each do |name|
+          Spontaneous::Publishing::Progress.registered[name] = klass
+        end
+      end
+    end
+
+    class Silent < Progress
+      attr_reader :total, :stage
+
+      register self, :silent, :none
+
+      def initialize
+        @total = 0
+        @position  = 0
+        @stage = ""
+        @start = Time.now
+      end
+
+      def start(total_steps)
+        @total = total_steps
+      end
+
+      def stage(name)
+        @stage = name
+      end
+
+      def current_stage
+        @stage
+      end
+
+      def step(n = 1, msg = "")
+        @position += n
+      end
+
+      def log(message)
+      end
+
+      def error(exception)
+      end
+
+      def done
+      end
+
+      def percentage
+        ((@position.to_f / @total.to_f) * 100).round(2)
+      end
+
+      def position
+        @position
+      end
+
+      def duration
+        Duration.new(Time.now - @start)
+      end
+    end
+
+    class Log < Silent
+      register self, :log
+
+      def initialize(io = $stdout, label = "Publish")
+        super()
+        # don't call close on stdout or stderr
+        @closable = !((io == STDOUT) || (io == STDERR))
+        @logger = Logger.new(io, File::APPEND)
+        @logger.formatter = proc do |severity, datetime, progname, msg|
+          pct = ("%03.2f" % [percentage]).rjust(6, " ")
+          "#{label}:#{severity}: [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%3N')}] #{duration} #{pct}% #{current_stage} #{msg}\n"
+        end
+      end
+
+      def log(message)
+        super
+        logger.info(message)
+      end
+
+      def step(n = 1, msg = "")
+        super
+        @logger.info("#{msg}")
+      end
+
+      def error(exception)
+        super
+        msg = [exception.to_s].concat(exception.backtrace).join("\n")
+        @logger.error(msg)
+      end
+
+      def done
+        @logger.close if @closable
+      end
+    end
+
+    class Stdout < Log
+      register self, :stdout
+
+      def initialize
+        super($stdout)
+      end
+    end
+
+    class Simultaneous < Silent
+      register self, :simultaneous, :browser
+
+      def stage(name)
+        super
+        send_event
+      end
+
+      def step(n = 1, msg = "")
+        super
+        send_event
+      end
+
+      def send_event(stage = current_stage, percentage = percentage)
+        ::Simultaneous.send_event('publish_progress', {:state => stage, :progress => percentage}.to_json)
+      rescue Errno::ECONNREFUSED
+      rescue Errno::ENOENT
+      end
+
+      def error(exception)
+        super
+        send_event("aborting", "*")
+      end
+
+      def done
+        super
+        send_event("complete", "*")
+      end
+    end
+
+    class Multi < Progress
+      def initialize(*outputs)
+        @outputs = outputs
+      end
+
+      def log(message)
+        @outputs.each { |progress| progress.log(message) }
+      end
+
+      def start(total_steps)
+        @outputs.each { |progress| progress.start(total_steps) }
+      end
+
+      def stage(name)
+        @outputs.each { |progress| progress.stage(name) }
+      end
+
+      def step(n = 1, msg = "")
+        @outputs.each { |progress| progress.step(n, msg) }
+      end
+
+      def error(exception)
+        @outputs.each { |progress| progress.error(exception) }
+      end
+
+      def done
+        @outputs.each { |progress| progress.done }
+      end
+    end
+  end
+end

data/lib/spontaneous/publishing/publish.rb

@@ -0,0 +1,107 @@
+
+module Spontaneous::Publishing
+  class Publish
+    attr_reader :site, :revision, :actions
+
+    def initialize(site, revision, actions)
+      @site, @revision, @actions = site, revision, actions
+    end
+
+    def publish_pages(modified_pages)
+      pages = normalise_page_list(modified_pages)
+      if all_pages?(pages) || all_modified_pages?(pages)
+        publish_all
+      else
+        pages = Spontaneous::Change.include_dependencies(pages)
+        publish(pages)
+      end
+    end
+
+    def publish_all
+      publish(nil)
+    end
+
+    def publish(pages)
+      model.database.transaction do
+        publish!(pages)
+      end
+    rescue Exception => e
+      abort_publish(e)
+      raise
+    end
+
+    def publish!(pages)
+      start_publish
+      model.publish(revision, pages) do
+        run_pipeline(pages)
+      end
+      finish_publish
+    end
+
+    def run_pipeline(pages)
+      model.scope(revision, true) do
+        run_pipeline!(pages)
+      end
+    end
+
+    def run_pipeline!(pages)
+      pages ||= all_unpublished_pages
+      pipeline.run(site, revision, pages, progress)
+    end
+
+    def pipeline
+      @pipeline ||= Pipeline.new(actions.steps)
+    end
+
+    def start_publish
+      progress.log("Publishing revision #{revision}")
+      # when working with multiple instances it's possible to rollback the revision number
+      # leaving behind old revisions > the current published_revision.
+      model.delete_revision(revision)
+      site.send(:pending_revision=, revision)
+    end
+
+    def finish_publish
+      S::PublishedRevision.create(:revision => revision, :published_at => Time.now)
+      site.send(:pending_revision=, nil)
+      site.must_publish_all!(false)
+      progress.done
+    end
+
+    def abort_publish(e)
+      S::PublishedRevision.filter(:revision => revision).delete
+      site.send(:pending_revision=, nil)
+      progress.error(e)
+    end
+
+    def model
+      @site.model
+    end
+
+    def progress
+      @progress ||= Progress::Multi.new(*actions.progress)
+    end
+
+    def normalise_page_list(pages)
+      pages = pages.flatten.map { |c|
+        c.is_a?(model::Page) ? c.reload : model::Page[c]
+      }
+    end
+
+    def all_unpublished_pages
+      @all_unpublished_pages ||= Spontaneous::Change.unpublished_pages(@site)
+    end
+
+    def all_pages
+      site.pages
+    end
+
+    def all_pages?(pages)
+      (all_pages - pages).empty?
+    end
+
+    def all_modified_pages?(pages)
+      (all_unpublished_pages - pages).empty?
+    end
+  end
+end

data/lib/spontaneous/publishing/rerender.rb

@@ -0,0 +1,17 @@
+module Spontaneous::Publishing
+  class Rerender < Publish
+    def initialize(site, revision, actions)
+      @site, @revision, @actions = site, revision, actions
+    end
+
+    def rerender
+      model.scope(revision, true) do
+        pipeline.run(site, revision, [], progress)
+      end
+    end
+
+    def progress
+      @progress ||= Progress::Stdout.new
+    end
+  end
+end

data/lib/spontaneous/publishing/revision.rb

@@ -1,6 +1,31 @@
 # encoding: UTF-8
 
 module Spontaneous::Publishing
+  def self.create_content_table(db, source_table, dest_table_name)
+    # sqlite doesn't like it if you create a table with no columns
+    # so hard-code the id column (but don't make it a pk because the
+    # unique constraint isn't useful at this stage)
+    schema = db.schema(source_table).dup.delete_if { |col, opts| col == :id }
+    db.create_table(dest_table_name) do
+      integer :id
+    end
+    db.alter_table(dest_table_name) do
+      schema.each do |column, column_opts|
+        opts = column_opts.dup
+        type = opts.delete(:db_type)
+        case column
+        when :id
+          opts.delete(:default)
+        end
+        add_column column, type#, opts
+      end
+    end
+    nil
+  rescue => e
+    db.drop_table(dest_table_name) rescue nil
+    raise
+  end
+
   class Revision
     class InvalidRevision < Spontaneous::Error; end
 
@@ -23,24 +48,24 @@ module Spontaneous::Publishing
           sync_revision
           set_revision_timestamps
           set_revision_version
+          set_revision_content_hash
           @revision.complete
           @revision.scope do
             yield if block_given?
           end
           set_source_timestamps
-        rescue => e
+          set_source_content_hash
+        rescue Exception => e # Want to catch everything, including the "uncatchable"
           @revision.delete
-          raise e
+          raise
         end
       end
 
       protected
 
       def create_revision
-        db.run(<<-SQL)
-          CREATE TABLE #{db.literal(@revision.table)}
-            AS #{source_dataset.select_sql}
-        SQL
+        Spontaneous::Publishing.create_content_table(db, source_dataset.first_source, @revision.table)
+        @revision.copy_dataset(source_dataset, @revision.table)
       end
 
       def source_dataset
@@ -48,6 +73,8 @@ module Spontaneous::Publishing
       end
 
       def copy_indexes
+        pk = @revision.model.primary_key
+        db.add_index(@revision.table, Array(pk), unique: true)
         indexes = db.indexes(@revision.content_table)
         indexes.each do |name, options|
           columns = options.delete(:columns)
@@ -59,6 +86,18 @@ module Spontaneous::Publishing
         # To be overwritten in Patch subclass
       end
 
+      def set_source_content_hash
+        set_content_hash(@revision.content_dataset)
+      end
+
+      def set_revision_content_hash
+        set_content_hash(@revision.dataset)
+      end
+
+      def set_content_hash(dataset)
+        filter_dataset(dataset).update(published_content_hash: :content_hash, content_hash_changed: false)
+      end
+
       def set_revision_timestamps
         set_timestamps(@revision.dataset)
       end
@@ -83,11 +122,11 @@ module Spontaneous::Publishing
       end
 
       def published_dataset(ds)
-        ds
+        filter_dataset(ds)
       end
 
       def first_published_dataset(ds)
-        ds.filter(:first_published_at => nil)
+        filter_dataset(ds.filter(:first_published_at => nil))
       end
 
       def set_revision_version
@@ -105,6 +144,10 @@ module Spontaneous::Publishing
       def revision
         @revision.revision
       end
+
+      def filter_dataset(ds)
+        ds
+      end
     end
 
     class Patcher < Generator
@@ -126,15 +169,7 @@ module Spontaneous::Publishing
         end
       end
 
-      def published_dataset(ds)
-        filter_ids(super)
-      end
-
-      def first_published_dataset(ds)
-        filter_ids(super)
-      end
-
-      def filter_ids(ds)
+      def filter_dataset(ds)
         ds.filter(:id => @modified.map(&:id))
       end
     end
@@ -211,7 +246,7 @@ module Spontaneous::Publishing
       model.mapper.revision_table?(table)
     end
 
-    attr_reader :revision
+    attr_reader :model, :revision
 
     def initialize(model, revision)
       @model, @revision = model, revision