spontaneous 0.2.0.beta5 → 0.2.0.beta6

data/lib/spontaneous/publishing/simultaneous.rb

@@ -26,7 +26,7 @@ module Spontaneous
 
       attr_reader :revision
 
-      def initialize(revision, content_model)
+      def initialize(revision, content_model, steps)
         @revision, @content_model = revision, content_model
       end
 

data/lib/spontaneous/publishing/steps.rb

@@ -0,0 +1,154 @@
+
+module Spontaneous::Publishing
+  module Steps
+    class InvalidStepException < Spontaneous::Error
+      def initialize(step)
+        super("Unknown/invalid step #{step.inspect}")
+      end
+    end
+    class InvalidProgressException < Spontaneous::Error
+      def initialize(progress)
+        super("Unknown/invalid progress #{progress.inspect}")
+      end
+    end
+
+    def self.new(steps = [], progress = [], &block)
+      Steps.new(steps, progress, &block)
+    end
+
+    def self.minimal
+      new do
+        run :activate_revision
+      end
+    end
+
+    def self.rerender
+      new do
+        run :render_revision
+      end
+    end
+
+    def self.default
+      new do
+        CORE_STEPS.each do |step|
+          run step
+        end
+      end
+    end
+
+    def self.register_step(step_class)
+      registered_steps[step_class.to_sym] = step_class
+    end
+
+    def self.registered_steps
+      @registered_steps ||= {}
+    end
+
+    class DSL
+      def initialize(steps, &block)
+        @steps = steps
+        instance_eval(&block) if block
+      end
+
+      def notify(progress, *args)
+        @steps.add_progress(validate_progress(make_progress(progress, args)))
+      end
+
+      alias_method :log, :notify
+
+      def run(step)
+        @steps.add_step(validate_step(make_step(step)))
+      end
+
+      def validate_progress(progress)
+        raise InvalidProgressException.new(progress) unless progress && is_progress?(progress)
+        progress
+      end
+
+      def make_progress(progress, args)
+        return progress if is_progress?(progress)
+        progress_class = case progress
+        when Symbol
+          Spontaneous::Publishing::Progress.registered[progress]
+        else
+          raise InvalidProgressException.new(progress)
+        end
+        return nil if progress_class.nil?
+        progress_class.new(*args)
+      end
+
+      def is_progress?(obj)
+        [:start, :stage, :step, :log, :done].all? { |method| obj.respond_to?(method) }
+      end
+
+      def validate_step(step)
+        raise InvalidStepException.new(step) unless step && step.respond_to?(:call)
+        step
+      end
+
+      def make_step(step)
+        return step if step.respond_to?(:call)
+        case step
+        when Symbol
+          Spontaneous::Publishing::Steps.registered_steps[step]
+        else
+          raise InvalidStepException.new(step)
+        end
+      end
+    end
+
+    class Steps
+      attr_reader :steps, :progress
+
+      def initialize(steps = [], progress = [], &block)
+        @steps, @progress = steps, progress
+        DSL.new(self, &block)
+      end
+
+      def add_progress(reporter)
+        progress << reporter
+      end
+
+      def add_step(step)
+        steps << step
+      end
+
+      def run(site, revision, pages, progress)
+        @steps.each do |step|
+          progress.add(step.count(site, revision)) if step.respond_to?(:count)
+        end
+
+        @steps.each do |step|
+          step.call(site, revision, pages, progress)
+        end
+      end
+
+      def to_a
+        steps
+      end
+    end
+
+    CORE_STEPS = [
+      :create_revision_directory,
+      :render_revision,
+      :generate_search_indexes,
+      :copy_static_files,
+      :generate_rackup_file,
+      :activate_revision,
+      :write_revision_file,
+      :archive_old_revisions
+    ].freeze
+
+    CORE_PROGRESS = [:browser, :stdout].freeze
+  end
+end
+
+require 'spontaneous/publishing/steps/base_step'
+require 'spontaneous/publishing/steps/create_revision_directory'
+require 'spontaneous/publishing/steps/render_revision'
+require 'spontaneous/publishing/steps/generate_search_indexes'
+require 'spontaneous/publishing/steps/copy_static_files'
+require 'spontaneous/publishing/steps/generate_rackup_file'
+require 'spontaneous/publishing/steps/activate_revision'
+require 'spontaneous/publishing/steps/write_revision_file'
+require 'spontaneous/publishing/steps/archive_old_revisions'

data/lib/spontaneous/publishing/steps/activate_revision.rb

@@ -0,0 +1,45 @@
+module Spontaneous::Publishing::Steps
+  class ActivateRevision < BaseStep
+
+    def count
+      2
+    end
+
+    def call
+      save_state
+      @progress.stage("activating revision")
+      set_published_revision
+      symlink_revision(revision)
+    end
+
+    def rollback
+      @site.send(:set_published_revision, @state.published_revision)
+      if @linked
+        symlink_path(@linked)
+      else
+        FileUtils.rm(@site.revision_dir) if File.exist?(@site.revision_dir)
+      end
+    end
+
+    def set_published_revision
+      @site.send(:set_published_revision, revision)
+      @progress.step(1, "published revision => #{revision}")
+    end
+
+    def symlink_revision(r)
+      path = @site.revision_dir(r)
+      symlink_path(path)
+      @progress.step(1, %(symlinking "revisions/current" => "#{path}"))
+    end
+
+    def symlink_path(path)
+      system("ln -nsf #{path} #{@site.revision_dir}")
+    end
+
+    def save_state
+      @state = @site.state
+      link = Pathname.new(@site.revision_dir)
+      @linked = link.realpath.to_s if link.exist?
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/archive_old_revisions.rb

@@ -0,0 +1,22 @@
+module Spontaneous::Publishing::Steps
+  class ArchiveOldRevisions < BaseStep
+    KEEP_REVISIONS = 8
+
+    def count
+      1
+    end
+
+    def call
+      @progress.stage("archiving old revisions")
+      @site.model.cleanup_revisions(revision, keep_revisions)
+      @progress.step(1)
+    end
+
+    def rollback
+    end
+
+    def keep_revisions
+      @site.config.keep_revisions || KEEP_REVISIONS
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/base_step.rb

@@ -0,0 +1,49 @@
+module Spontaneous::Publishing::Steps
+  class BaseStep
+
+    def self.to_sym
+      name.demodulize.underscore.to_sym
+    end
+
+    def self.count(site, revision, pages, progress = Spontaneous::Publishing::Progress::Silent.new)
+      new(site, revision, pages, progress).count
+    end
+
+    # create, run & return an instance that does the actual work
+    def self.call(site, revision, pages, progress = Spontaneous::Publishing::Progress::Silent.new)
+      new(site, revision, pages, progress).tap do |instance|
+        begin
+          instance.call
+        rescue Exception => e
+          instance.rollback #if instance.respond_to?(:rollback)
+          raise
+        end
+      end
+    end
+
+    def self.inherited(subclass)
+      Spontaneous::Publishing::Steps.register_step(subclass)
+    end
+
+    attr_reader :revision, :site, :progress
+
+    def initialize(site, revision, pages, progress)
+      @site, @revision, @pages, @progress = site, revision, pages, progress
+    end
+
+    # Does the actual work
+    def call
+      # implement in subclasses
+    end
+
+    # Should return the number of steps we're going to make
+    def count
+      # implement in subclasses
+    end
+
+    # Undo what we did in #call in case of exceptions
+    def rollback
+      # implement in subclasses
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/copy_static_files.rb

@@ -0,0 +1,74 @@
+module Spontaneous::Publishing::Steps
+  class CopyStaticFiles < BaseStep
+
+    def count
+      facets.length
+    end
+
+    def call
+      @progress.stage("copying files")
+      ensure_public_dir
+      facets.each do |facet|
+        copy_facet(facet)
+        @progress.step(1, "from #{facet.name.inspect}")
+      end
+    end
+
+    def rollback
+      FileUtils.rm_r(revision_public) if File.exists?(revision_public)
+    end
+
+    def ensure_public_dir
+      dir = revision_public
+    end
+
+    def copy_facet(facet)
+      sources(facet).each do |dir|
+        copy_files(facet, dir)
+      end
+    end
+
+    def copy_files(facet, dir)
+      files(dir).each do |source, path|
+        copy_file(facet, source, path)
+      end
+    end
+
+    def copy_file(facet, source, path)
+      dest = File.join([revision_public, facet.file_namespace, path].compact)
+      dir = File.dirname(dest)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      link_file(source, dest)
+    end
+
+    def link_file(source, dest)
+      src_dev = File::stat(source).dev
+      dst_dev = File::stat(File.dirname(dest)).dev
+      if (src_dev == dst_dev)
+        FileUtils.ln(source, dest, :force => true)
+      else
+        FileUtils.cp(source, dest)
+      end
+    end
+
+    def files(dir)
+      Dir["#{dir}/**/*"]
+      .reject {|path| ::File.directory?(path) }
+      .map { |path| [path, Pathname.new(path).relative_path_from(dir).to_s] }
+    end
+
+    def revision_public
+      @public_dest ||= Pathname.new(Spontaneous.revision_dir(revision) / 'public').tap do |path|
+        FileUtils.mkdir_p(path) unless File.exists?(path)
+      end
+    end
+
+    def facets
+      @site.facets
+    end
+
+    def sources(facet)
+      facet.paths.expanded(:public).map { |dir| Pathname.new(dir) }.select(&:exist?).map(&:realpath)
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/create_revision_directory.rb

@@ -0,0 +1,24 @@
+# Should be called *after* the revision
+module Spontaneous::Publishing::Steps
+  class CreateRevisionDirectory < BaseStep
+
+    def call
+      @progress.stage("creating revision directory")
+      FileUtils.mkdir_p(path / "tmp")
+      @progress.step(count, path)
+    end
+
+    def count
+      1
+    end
+
+    # This is the reason for the existance of this step: cleaning up when it's gone wrong
+    def rollback
+      FileUtils.rm_r(path) if File.exist?(path)
+    end
+
+    def path
+      @site.revision_dir(revision)
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/generate_rackup_file.rb

@@ -0,0 +1,51 @@
+module Spontaneous::Publishing::Steps
+  class GenerateRackupFile < BaseStep
+
+    def call
+      @progress.stage("create server config")
+      File.open(config_path, "w:UTF-8") do |file|
+        file.write(config)
+      end
+      @progress.step(count, config_path.inspect)
+    end
+
+    def count
+      1
+    end
+
+    def rollback
+      FileUtils.rm(config_path) if File.exists?(config_path)
+    end
+
+    def config_path
+      (@site.revision_dir(revision) / "config.ru").tap do |path|
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      end
+    end
+
+    def path
+      @path ||= Pathname.new(@site.root).realpath.to_s
+    end
+
+    def config
+      path = Pathname.new(Spontaneous.root).realpath.to_s
+      rackup = "config/front.ru"
+
+      template = (<<-RACKUP).gsub(/^ +/, '')
+        # This is an automatically generated file *DO NOT EDIT*
+        # To configure your Rack application make your changes in
+        # '#{path}/#{rackup}'
+
+        # Set the revision to display
+        ENV["#{Spontaneous::SPOT_REVISION_NUMBER}"] = "#{revision}"
+        ENV["#{Spontaneous::SPOT_ROOT}"] = "#{path}"
+
+        # Change to the absolute path of our application and load the Rack config
+        root = "#{path}"
+        Dir.chdir(root)
+        eval(::File.read("#{rackup}"), binding, ::File.join(root, "#{rackup}"), __LINE__)
+      RACKUP
+    end
+  end
+end

data/lib/spontaneous/publishing/steps/generate_search_indexes.rb

@@ -0,0 +1,24 @@
+module Spontaneous::Publishing::Steps
+  class GenerateSearchIndexes < BaseStep
+
+    def call
+      return if indexes.empty?
+      @progress.stage("indexing")
+      @site.indexer(revision) do |indexer|
+        @site.pages.each do |page|
+          indexer << page
+          @progress.step(1, page.path.inspect)
+        end
+      end
+    end
+
+    def count
+      return 0 if indexes.empty?
+      @site.pages.count
+    end
+
+    def indexes
+      site.indexes
+    end
+  end
+end