spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -78,6 +78,7 @@ module Spontaneous::Prototypes
         @extend.each { |block|
           instance_class.class_eval(&block) if block
         }
+        instance_class.prototype = self
       end
     end
 
@@ -85,8 +86,13 @@ module Spontaneous::Prototypes
       instance_class
     end
 
-    def default
-      @options[:default]
+    def default(_instance = nil)
+      case default = @options[:default]
+      when Proc
+        default[_instance]
+      else
+        default
+      end
     end
 
     def comment
@@ -134,13 +140,12 @@ module Spontaneous::Prototypes
       end
     end
 
-    def to_field(values=nil)
-      default_values = values.nil?
-      values = {
-        :name => self.name,
-        :unprocessed_value => default
-      }.merge(values || {})
-      self.instance_class.new(values, !default_values).tap do |field|
+    def to_field(instance, database_values=nil)
+      using_default_values = database_values.nil?
+      values = { :name => self.name }
+      values[:unprocessed_value] = default(instance) if using_default_values
+      values.update(database_values || {})
+      self.instance_class.new(values, !using_default_values).tap do |field|
         field.prototype = self
       end
     end
@@ -153,7 +158,7 @@ module Spontaneous::Prototypes
         :title => title,
         :comment => comment || "",
         :writable => Spontaneous::Permissions.has_level?(user, write_level)
-      }
+      }.merge(instance_class.export(user))
     end
   end
 end

data/lib/spontaneous/publishing/event_client.rb

@@ -0,0 +1,46 @@
+require 'socket'
+require 'net/http'
+
+module Spontaneous
+  module Publishing
+    # a simple UNIX socket capable HTTP client used to send progress events
+    # from the publish task to the back server (for forwarding onto clients)
+    class EventClient
+      def initialize(server_address)
+        @server_address = server_address
+      end
+
+      def send_event(event_name, event_message)
+        socket = open_socket
+        return if socket.nil?
+        sock = Net::BufferedIO.new(socket)
+        request = request(event_name, event_message)
+        # Host is a required header, but it doesn't matter to us what it is
+        request["Host"] = "localhost"
+        request.exec(sock, "1.1", request.path)
+      ensure
+        sock.close if sock
+      end
+
+      def request(event_name, event_message)
+        query = ::Rack::Utils.build_nested_query({
+          "event" => event_name,
+          "data"  => event_message.to_json
+        })
+        Net::HTTP::Put.new("/@spontaneous/event?#{query}")
+      end
+
+
+      def open_socket
+        return nil if @server_address.nil?
+        case @server_address
+        when /\//
+          UNIXSocket.new(@server_address)
+        else
+          host, port = @server_address.split(":")
+          TCPSocket.new(host, port)
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/publishing/immediate.rb

@@ -6,39 +6,37 @@ require 'sass'
 module Spontaneous
   module Publishing
     class Immediate
-
-      # def self.status
-      #   @status ||= ""
-      # end
-
-      # def self.status=(status)
-      #   @status = status
-      # end
-
       include ::Simultaneous::Task
 
       attr_reader :revision
 
       def initialize(revision)
         @revision = revision
-        logger.info {  "Publishing revision #{@revision}"}
+        @previous_revision = Site.published_revision
       end
 
-      def publish_changes(change_list)
-        changes = change_list.flatten.map { |c|
-          c.is_a?(S::Change) ? c : S::Change[c]
+      def renderer
+        @renderer ||= Spontaneous::Output::Template::PublishRenderer.new(true)
+      end
+
+      def publish_pages(page_list)
+        pages = page_list.flatten.map { |c|
+          c.is_a?(S::Page) ? c.reload : S::Page[c]
         }
-        all_changes = S::Change.all
-        if changes == all_changes
+        all_pages = S::Page.all
+
+        if (all_pages - pages).empty?
           # publish_all is quicker
           publish_all
         else
-          change_set = Spontaneous::Collections::ChangeSet.new(changes)
-          publish(change_set.page_ids)
-
-          changes.each do |change|
-            change.destroy
-          end
+          pages = Spontaneous::Change.include_dependencies(pages)
+          # changes = pages.map { |page| Spontaneous::Change.new(page) }
+          publish(pages)
+
+          # TODO: scheduled publishes will
+          # changes.each do |change|
+          #   change.destroy
+          # end
         end
 
       end
@@ -48,19 +46,26 @@ module Spontaneous
         # (but after we've duplicated the tables)
         # so save the current list of changes
         # TODO: make sure this is robust
-        changes = S::Change.all
+        # changes = S::Change.all
         publish(nil)
-        changes.each do |change|
-          change.destroy
+        # changes.each do |change|
+        #   change.destroy
+        # end
+      end
+
+      def rerender_revision
+        logger.info {  "Re-rendering revision #{@revision}"}
+        S::Content.with_revision(@revision) do
+          render_revision
         end
       end
 
       protected
 
-      def page_rendered(page, event = "rendering")
+      def page_rendered(page, event = "rendering", format = "html")
         @pages_rendered += 1
         update_progress(event, percent_complete)
-        logger.info { "Done: #{event} page #{page.path} #{percent_complete.round(1)}%" }
+        logger.info { "Done: #{event} page #{page.path} (#{format}) #{percent_complete.round(1)}%" }
       end
 
 
@@ -76,6 +81,7 @@ module Spontaneous
       end
 
       def publish(modified_page_list)
+        logger.info {  "Publishing revision #{@revision}"}
         at_exit {
           abort_publish_at_exit
         }
@@ -85,21 +91,20 @@ module Spontaneous
             render_revision
           end
           after_publish
-        rescue Exception => e
+        rescue ::Exception => e
           abort_publish(e)
           raise(e)
         end
       end
 
       def render_revision
+        S::Output.renderer = renderer
         update_progress("rendering", 0)
         @pages_rendered = 0
         S::Content.with_identity_map do
           S::Content.with_visible do
-            S::Render.with_publishing_renderer do
-              render_pages
-              index_pages unless index_stages == 0
-            end
+            render_pages
+            index_pages unless index_stages == 0
           end
         end
         copy_static_files
@@ -110,19 +115,17 @@ module Spontaneous
         # the delay is purely used in interface testing
         delay = Spontaneous::Site.config.publishing_delay
         pages.each do |page|
-          page.formats.each do |format|
-            render_page(page, format)
+          page.outputs.each do |output|
+            render_page(page, output)
           end
           sleep(delay) if delay
         end
       end
 
-      def render_page(page, format)
+      def render_page(page, output)
         logger.info { "#{page.path}" }
-        formatter = Spontaneous::Render::Format.for(format)
-        renderer = formatter.new(revision, page)
-        renderer.render
-        page_rendered(page)
+        output.publish_page(renderer, revision)
+        page_rendered(page, "rendering", output.format)
       end
 
       def index_pages
@@ -140,7 +143,7 @@ module Spontaneous
       # although not all pages are included by a format
       def total_pages_to_render
         @total_pages ||= (index_stages * pages.count) + pages.inject(0) do |total, page|
-          total += page.formats.length#count { |page| page.formats.include?(format) }
+          total += page.outputs.length
         end
       end
 
@@ -148,6 +151,12 @@ module Spontaneous
         ((@pages_rendered || 0).to_f / (total_pages_to_render).to_f) * 100.0
       end
 
+      # Deprecated. It's easier to use the messaging path provided by Simultaneous
+      # as it's auto configuring.
+      def event_client
+        @event_client ||= Spontaneous::Publishing::EventClient.new(ENV["SPOT_SERVER"])
+      end
+
       def update_progress(state, progress='*')
         simultaneous_event('publish_progress', {:state => state, :progress => progress}.to_json)
       end
@@ -208,7 +217,7 @@ module Spontaneous
                 when ".scss"
                   render_sass_template(src, dest)
                 else
-                  FileUtils.ln(src, dest, :force => true)
+                  link_file(src, dest)
                 end
               end
             end
@@ -216,6 +225,16 @@ module Spontaneous
         end
       end
 
+      def link_file(src, dest)
+        src_dev = File::stat(src).dev
+        dst_dev = File::stat(File.dirname(dest)).dev
+        if (src_dev == dst_dev)
+          FileUtils.ln(src, dest, :force => true)
+        else
+          FileUtils.cp(src, dest)
+        end
+      end
+
       def render_sass_template(template, dest)
         dest_css = [dest.basename('.scss'), "css"].join(".")
         dest = (dest.dirname + dest_css)
@@ -243,6 +262,9 @@ module Spontaneous
 
       def before_publish
         update_progress("initialising")
+        # when working with multiple instances it's possible to rollback the revision number
+        # leaving behind old revisions > the current published_revision.
+        S::Content.delete_revision(revision)
         S::Site.send(:pending_revision=, revision)
       end
 
@@ -250,11 +272,26 @@ module Spontaneous
         update_progress("finalising")
         S::Revision.create(:revision => revision, :published_at => Time.now)
         S::Site.send(:set_published_revision, revision)
-        S::Site.send(:pending_revision=, nil)
         tmp = Spontaneous.revision_dir(revision) / "tmp"
         FileUtils.mkdir_p(tmp) unless ::File.exists?(tmp)
-        system("ln -nsf #{Spontaneous.revision_dir(revision)} #{Spontaneous.revision_dir}")
-        update_progress("complete")
+        symlink_revision(revision)
+
+        begin
+          S::Site.trigger(:after_publish, revision)
+          S::Site.send(:pending_revision=, nil)
+          update_progress("complete")
+        rescue Exception => e
+          # if a post publish hook raises an exception then we want to roll everything back
+          S::Revision.filter(:revision => revision).delete
+          S::Site.send(:set_published_revision, @previous_revision)
+          symlink_revision(@previous_revision)
+          abort_publish(e)
+          raise e
+        end
+      end
+
+      def symlink_revision(rev)
+        system("ln -nsf #{Spontaneous.revision_dir(rev)} #{Spontaneous.revision_dir}")
       end
 
       def abort_publish_at_exit
@@ -267,7 +304,7 @@ module Spontaneous
           FileUtils.rm_r(Spontaneous.revision_dir(revision)) if File.exists?(Spontaneous.revision_dir(revision))
           S::Site.send(:pending_revision=, nil)
           S::Content.delete_revision(revision)
-          puts exception.backtrace.join("\n")
+          puts exception.backtrace.join("\n") if exception
           update_progress("error", exception)
         end
       end

data/lib/spontaneous/publishing/simultaneous.rb

@@ -11,8 +11,16 @@ 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 = (Pathname.new(Spontaneous.gem_dir) + "bin/spot site:publish").expand_path.to_s
+        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"
@@ -22,17 +30,26 @@ module Spontaneous
           :logfile => logfile,
           :pwd => site_root
         }
+
         task_params = {
           "site" => site_root,
           "logfile" => logfile,
           "environment" => Spontaneous.env
         }
-        ::Simultaneous.add_task(task_name, publish_binary, task_options, task_params, {})
+        env = {
+          "SPOT_SERVER" => server_address
+        }
+        ::Simultaneous.add_task(task_name, publish_binary, task_options, task_params, env)
       end
 
       def self.simultaneous_setup
-        ::Simultaneous.connection = ::Spontaneous.config.simultaneous_connection
-        ::Simultaneous.domain = ::Spontaneous.config.site_domain
+        ::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
@@ -56,8 +73,8 @@ module Spontaneous
         self.class.task_name
       end
 
-      def publish_changes(change_list)
-        ::Simultaneous.fire(task_name, {"changes" => change_list})
+      def publish_pages(page_list)
+        ::Simultaneous.fire(task_name, {"pages" => page_list})
       end
 
       def publish_all

data/lib/spontaneous/publishing.rb

@@ -2,9 +2,10 @@
 
 module Spontaneous
   module Publishing
-    autoload :Immediate, "spontaneous/publishing/immediate"
-    autoload :Threaded, "spontaneous/publishing/threaded"
-    autoload :Simultaneous, "spontaneous/publishing/simultaneous"
+    autoload :Immediate,      "spontaneous/publishing/immediate"
+    autoload :Threaded,       "spontaneous/publishing/threaded"
+    autoload :Simultaneous,   "spontaneous/publishing/simultaneous"
+    autoload :EventClient,    "spontaneous/publishing/event_client"
   end # Publishing
 end # Spontaneous
 

data/lib/spontaneous/rack/around_back.rb

@@ -11,11 +11,7 @@ module Spontaneous
       def call(env)
         response = nil
         Content.with_identity_map do
-          S::Render.with_preview_renderer do
-            Change.record do
-              response = @app.call(env)
-            end
-          end
+          response = @app.call(env)
         end
         response
       end

data/lib/spontaneous/rack/around_front.rb

@@ -9,15 +9,15 @@ module Spontaneous
     class AroundFront
       def initialize(app)
         @app = app
+        @renderer = Spontaneous::Output.published_renderer
       end
 
       def call(env)
         status = headers = body = nil
+        env[Rack::RENDERER] = @renderer
         Content.with_identity_map do
-          S::Render.with_published_renderer do
-            Site.with_published do
-              status, headers, body = @app.call(env)
-            end
+          Site.with_published do
+            status, headers, body = @app.call(env)
           end
         end
         [status, headers.merge(POWERED_BY), body]

data/lib/spontaneous/rack/around_preview.rb

@@ -5,14 +5,15 @@ module Spontaneous
     class AroundPreview
       def initialize(app)
         @app = app
+        @renderer = Spontaneous::Output.preview_renderer
+        Spontaneous::Output.renderer = @renderer
       end
 
       def call(env)
+        env[Rack::RENDERER] = @renderer
         response = nil
         Content.with_identity_map do
-          S::Render.with_preview_renderer do
-            response = @app.call(env)
-          end
+          response = @app.call(env)
         end
         response
       end

data/lib/spontaneous/rack/assets.rb

@@ -7,38 +7,69 @@ module Spontaneous
   module Rack
     module Assets
 
-      module Bundling
-        def compress_js(filelist, options={})
-          shine_compress_files(filelist, :js, options)
-        end
+      # module Bundling
+      #   extend self
+
+      #   def compress_js(filelist, options={})
+      #     shine_compress_files(filelist, :js, options)
+      #   end
+
+      #   def compress_css(filelist, options={})
+      #     # compress_files(filelist, :css, options)
+      #     options = {
+      #       :load_paths => [Spontaneous.css_dir],
+      #       # :filename => sass_template,
+      #       :cache => false,
+      #       :style => :compressed
+      #     }
+      #     paths = paths(filelist)
+      #     css = paths.map do |path|
+      #       Sass::Engine.for_file(path, options).render
+      #     end.join("\\n")
+      #     hash = digest(css)
+      #     [css, hash]
+      #   end
+
+      #   def shine_compress_files(filelist, format, options = {})
+      #     paths = paths(filelist)
+      #     original_size = filesize(paths)
+      #     compressed = Shine::compress_files(paths, format, options)
+      #     logger.info("Compressed #{filelist.length} files. Original size #{original_size}, compressed size #{compressed.length}, ratio #{(100*compressed.length.to_f/original_size.to_f).round}%")
+      #     hash = digest(compressed)
+      #     [compressed, hash]
+      #   end
+
+      #   def digest(str)
+      #     hash = Digest::SHA1.new.update(str).hexdigest
+      #   end
+
+      #   def paths(filelist)
+      #     filelist.map { |file| filepath(file) }.tap do |paths|
+      #       logger.info("Bundling #{paths.length} files")
+      #     end
+      #   end
+
+      #   def filepath(file)
+      #     File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
+      #   end
+
+      #   def filesize(paths)
+      #     paths.inject(0) { |sum, path| sum += File.size(path) }
+      #   end
+      # end
+      module JavaScript
+        extend Spontaneous::Output::Assets::Compression
 
-        def compress_css(filelist, options={})
-          # compress_files(filelist, :css, options)
-          options = {
-            :load_paths => [Spontaneous.css_dir],
-            # :filename => sass_template,
-            :cache => false,
-            :style => :compressed
-          }
-          paths = paths(filelist)
-          css = paths.map do |path|
-            Sass::Engine.for_file(path, options).render
-          end.join("\n")
-          hash = digest(css)
-          [css, hash]
+        def self.filetype
+          "js"
         end
 
-        def shine_compress_files(filelist, format, options = {})
-          paths = paths(filelist)
-          original_size = filesize(paths)
-          compressed = Shine::compress_files(paths, format, options)
-          logger.info("Compressed #{filelist.length} files. Original size #{original_size}, compressed size #{compressed.length}, ratio #{(100*compressed.length.to_f/original_size.to_f).round}%")
-          hash = digest(compressed)
-          [compressed, hash]
+        def self.extension
+          "js"
         end
 
-        def digest(str)
-          hash = Digest::SHA1.new.update(str).hexdigest
+        def self.compress(filelist)
+          compress_js(paths(filelist))
         end
 
         def paths(filelist)
@@ -51,32 +82,16 @@ module Spontaneous
           File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
         end
 
-        def filesize(paths)
-          paths.inject(0) { |sum, path| sum += File.size(path) }
-        end
-      end
-      module JavaScript
-        extend Spontaneous::Rack::Assets::Bundling
-
-        def self.filetype
-          "js"
-        end
-        def self.extension
-          "js"
-        end
-        def self.compress(filelist)
-          compress_js(filelist)
-        end
-
-        JQUERY = %w(min/2a0c2962537a3181fedfff5c92596ba6d3122dc9)
-        COMPATIBILITY = %w(min/4cf1c493d3379ecba5287758c61238034c0893f9)
-        REQUIRE = %w(min/b8abf302a824c35385ff517b34111e1710ff3b37)
-        LOGIN_JS = %w(min/78ac6b99d96750bb6b9f9aad4cb9cd91cd03f391)
-        EDITING_JS = %w(min/c8efb9b9f7c3f6613fcebc6be60f605b6570a382)
+        # TODO: remove these
+        JQUERY = %w(vendor/jquery)
+        COMPATIBILITY = []#%w(compatibility)
+        REQUIRE = %w(require)
+        LOGIN_JS = %w(login)
+        EDITING_JS = %w(spontaneous)
       end
 
       module CSS
-        extend Spontaneous::Rack::Assets::Bundling
+        extend Spontaneous::Output::Assets::Compression
 
         def self.filetype
           "css"
@@ -86,12 +101,24 @@ module Spontaneous
         end
 
         def self.compress(filelist)
-          compress_css(filelist)
+          compress_css(paths(filelist))
+        end
+
+
+        def paths(filelist)
+          filelist.map { |file| filepath(file) }.tap do |paths|
+            logger.info("Bundling #{paths.length} files")
+          end
+        end
+
+        def filepath(file)
+          File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
         end
 
-        LOGIN_CSS = %w(min/565d4c25e82148acb01c45c8d675b37a08676d77)
-        EDITING_CSS = %w(min/14c2a35812c443001b15d8b12a4780f88c678035)
-        SCHEMA_MODIFICATION_CSS = %w(min/84dbe894ea96eafd321c30823d630817bfc4b03b)
+        # TODO: remove these
+        LOGIN_CSS = %w(spontaneous) # login
+        EDITING_CSS = %w(spontaneous)
+        SCHEMA_MODIFICATION_CSS = %w(spontaneous) #schema_error
       end
 
     end # Assets

data/lib/spontaneous/rack/authentication.rb

@@ -12,7 +12,6 @@ module Spontaneous::Rack
         unless first_level_exceptions.any? { |e| e === request.path }
           ignore_key = second_level_exceptions.any? { |e| e === request.path }
           valid_key = ignore_key || Spontaneous::Permissions::AccessKey.valid?(params[KEY_PARAM], user)
-          halt(401, erb(:login, :views => Spontaneous.application_dir('/views'), :locals => { :login => '' })) unless (user and valid_key)
           show_login_page( :login => '' ) unless (user and valid_key)
         end
       }