spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/db/migrations/20130109125023_add_page_publish_lock.rb

@@ -0,0 +1,17 @@
+Sequel.migration do
+  up do
+    create_table!(:spontaneous_page_lock, :engine => "INNODB", :charset => "UTF8", :collate => "utf8_general_ci") do
+      primary_key :id
+
+      Integer  :page_id,    :index => true
+      Integer  :content_id, :index => true
+      String   :field_id
+      DateTime :created_at
+      String   :description
+    end
+  end
+
+  down do
+    drop_table :spontaneous_page_lock
+  end
+end

data/db/migrations/20130111161934_convert_bcrypt_passwords.rb

@@ -0,0 +1,22 @@
+
+Sequel.migration do
+  up do
+    scheme = Spontaneous::Crypt::Version::SHALegacy
+
+    dataset = self[:spontaneous_users]
+
+    dataset.each do |user|
+      hash = scheme.create(user[:crypted_password], user[:salt])
+      dataset.filter(:id => user[:id]).update(:crypted_password => hash)
+    end
+
+    drop_column :spontaneous_users, :salt
+  end
+
+  down do
+    # There's no way to recover from the conversion -- the
+    # hashed password is lost so all we can do is re-add the salt
+    # column
+    add_column :spontaneous_users, :salt
+  end
+end

data/db/migrations/20130114120000_create_revision_tables.rb

@@ -0,0 +1,106 @@
+
+require 'logger'
+require 'spontaneous'
+require 'benchmark'
+
+Sequel.migration do
+  ContentTable = S::DataMapper::ContentTable
+  revision_table = :spontaneous_content_revisions
+  archive_table  = :spontaneous_content_archive
+  content_table  = :content
+
+  keep_revisions = 10
+
+  logger = ::Logger.new($stdout)
+
+  up do
+
+    add_column content_table, :revision, :integer, :default => nil
+
+    state = self[:spontaneous_state].first
+
+    current_revision = state.nil? ? 0 : state[:published_revision]
+
+    [revision_table, archive_table].each do |table|
+      drop_table?(table)
+      run %(CREATE TABLE #{literal(table)} AS (SELECT * FROM #{literal(content_table)} LIMIT 1);)
+    end
+
+
+    tables = self.tables
+    revisions = tables.select { |t| ContentTable.revision_table?(content_table, t)}.sort
+
+    revisions = revisions.map { |name| [name, ContentTable.revision_number(content_table, name)] }
+
+    unless revisions.empty?
+
+      max_revision = revisions.map { |(table, revision)| revision }.max
+
+
+      keep_revision = max_revision - keep_revisions
+
+      columns = self[content_table].columns.
+        reject { |c| c == :revision }.
+        map { |c| literal(c)}
+
+      insert_columns = (columns + [literal(:revision)]).join(", ")
+      select_columns = columns.join(", ")
+
+      self.logger = nil
+
+      revisions.each do |(table, revision)|
+        begin
+          print ">> Copying revision #{revision} from table #{table} ... "
+          bm = Benchmark.measure do
+            transaction do
+              dest = archive_table
+              dest = revision_table if revision > keep_revision
+              run <<-SQL
+                INSERT #{literal(dest)} (#{insert_columns})
+                SELECT #{select_columns}, #{revision}
+                FROM #{literal(table)}
+              SQL
+              drop_table table unless revision == current_revision
+            end
+          end
+          puts " done (#{"%.4f" % bm.real}s)"
+        rescue Sequel::DatabaseError => e
+          logger.error(e.message)
+        end
+      end
+
+      self.logger = logger
+
+      # Dont want an index on the archive because the assumption is that we won't
+      # need it except for archival purposes and the index will add space & slow
+      # things down.
+      add_index revision_table, :revision
+
+      # Because of errors some of the revisions will have been left.
+      # Just delete them.
+      current_revision_table = ContentTable.revision_table(content_table, current_revision)
+      drop_tables = self.tables.
+        select { |t| ContentTable.revision_table?(content_table, t) }.
+        reject { |t| t == current_revision_table }
+
+      drop_tables.each do |table|
+        drop_table table
+      end
+    end
+    self.logger = nil
+  end
+
+  down do
+    # Not going to do a full down implementation until I need to
+    # If things have gone wrong then all is lost anyway, and I won't be able
+    # to recover the lost revision data.
+    # If all is well then recovering the revision tables from the archives
+    # is trivial (but dull).
+    [revision_table, archive_table].each do |table|
+      drop_table table
+    end
+
+    drop_column content_table, :revision
+  end
+end
+

data/db/migrations/20130116220423_add_index_to_archive.rb

@@ -0,0 +1,9 @@
+Sequel.migration do
+  up do
+    rename_table :spontaneous_content_revisions, :spontaneous_content_history
+  end
+
+  down do
+    rename_table :spontaneous_content_history, :spontaneous_content_revisions
+  end
+end

data/lib/spontaneous/box.rb

@@ -4,14 +4,14 @@ module Spontaneous
   class Box
     include Enumerable
 
-    include Plugins::SchemaHierarchy
-    include Plugins::Fields
-    include Plugins::Styles
-    include Plugins::Serialisation
-    include Plugins::Render
-    include Plugins::AllowedTypes
-    include Plugins::Permissions
-    include Plugins::Media
+    include Spontaneous::Model::Core::SchemaHierarchy
+    include Spontaneous::Model::Core::Fields
+    include Spontaneous::Model::Core::Styles
+    include Spontaneous::Model::Core::Serialisation
+    include Spontaneous::Model::Core::Render
+    include Spontaneous::Model::Box::AllowedTypes
+    include Spontaneous::Model::Core::Permissions
+    include Spontaneous::Model::Core::Media
 
     # use underscores to protect against field name conflicts
     attr_reader :_name, :_prototype, :owner
@@ -23,6 +23,10 @@ module Spontaneous
     # Returns: the owning Content object
     alias_method :parent, :owner
 
+    class << self
+      attr_reader :mapper
+    end
+
     def self.page?
       false
     end
@@ -41,7 +45,7 @@ module Spontaneous
     end
 
     def self.schema_id
-      Spontaneous.schema.uids[@schema_id] || Spontaneous.schema.schema_id(self)
+      mapper.schema.uids[@schema_id] || mapper.schema.to_id(self)
     end
 
     # This is overridden by anonymous classes defined by box prototypes
@@ -50,7 +54,6 @@ module Spontaneous
       "type//#{self.name}"
     end
 
-
     def self.supertype
       if self == Spontaneous::Box
         nil
@@ -72,6 +75,9 @@ module Spontaneous
       @field_initialization = false
     end
 
+    def model
+      @owner.model
+    end
 
     def page?
       false
@@ -87,8 +93,10 @@ module Spontaneous
       self.class.schema_id
     end
 
+    # A boxes "identity" must be a combination of its owner's id and
+    # its schema_id.
     def id
-      schema_id.to_s
+      [owner.id, schema_id.to_s].join("/")
     end
 
     def schema_name
@@ -123,6 +131,9 @@ module Spontaneous
       _name.to_s
     end
 
+    def reload
+      owner.reload
+    end
     # needed by Render::Context
     def box?(box_name)
       false
@@ -141,7 +152,7 @@ module Spontaneous
         default_values.each do |field_name, value|
           if self.field?(field_name)
             field = self.class.field_prototypes[field_name].to_field(self)
-            field.unprocessed_value = value
+            field.value = value
             field_store << field.serialize_db
           end
         end
@@ -149,16 +160,36 @@ module Spontaneous
       field_store
     end
 
-    def field_modified!(modified_field)
+    def field_modified!(modified_field = nil)
+      save_fields!
+    end
+
+    def save_fields(fields = nil)
+      save_fields!(fields)
+      save
+    end
+
+    # Use @serialized_fields to temporarily overwrite the value of
+    # #serialized_fields because this call may be coming from an async
+    # process that only wants to update a subset of the field values
+    # and because we don't have direct access to the serialization
+    # store we have to control our serialization output.
+    # TODO: Make boxes responsible for directly writing their serialized
+    # form
+    def save_fields!(fields = nil)
       @modified = true
+      @serialized_fields = update_serialized_fields(fields)
       owner.box_modified!(self)
+      @serialized_fields = nil
     end
 
     def serialize_db
-      {
-        :box_id => schema_id.to_s,
-        :fields => fields.serialize_db
-      }
+      { :box_id => schema_id.to_s,
+        :fields => serialized_fields }
+    end
+
+    def serialized_fields
+      @serialized_fields || fields.serialize_db
     end
 
     def self.resolve_style(box)
@@ -177,6 +208,10 @@ module Spontaneous
       owner
     end
 
+    def content_instance
+      owner
+    end
+
     def page
       owner.page
     end
@@ -224,7 +259,7 @@ module Spontaneous
     end
 
     def pieces
-      contents.select { |e| e.is_a?(Spontaneous::Piece) }
+      contents.select { |e| e.is_a?(Spontaneous::Model::Piece) }
     end
 
     def [](index)

data/lib/spontaneous/box_style.rb

@@ -6,7 +6,7 @@ module Spontaneous
     attr_reader :box
 
     def self.excluded_classes
-      [Spontaneous::Box].tap do |classes|
+      [Spontaneous::Box, Spontaneous::Content::Box].tap do |classes|
         classes.push(::Box) if defined?(::Box)
       end
     end
@@ -74,8 +74,7 @@ module Spontaneous
     end
 
     def anonymous_template
-      Proc.new { '#{ render_content }' }
+      Proc.new { '${ render_content }' }
     end
   end
 end
-

data/lib/spontaneous/change.rb

@@ -6,7 +6,10 @@ module Spontaneous
 
     class << self
       def outstanding
-        unpublished_changes
+        outstanding = { :published_revision => Spontaneous::Site.published_revision,
+          :changes => unpublished_changes }
+        outstanding[:first_publish] = true if outstanding[:published_revision] == 0
+        outstanding
       end
 
       def unpublished_changes
@@ -14,7 +17,7 @@ module Spontaneous
       end
 
       def unpublished_pages
-        S::Page.filter { (modified_at > last_published_at) | {:first_published_at => nil} }.order(:modified_at.desc).all
+        Spontaneous::Content::Page.filter { (modified_at > last_published_at) | {:first_published_at => nil} }.order(:modified_at.desc).all
       end
 
       def include_dependencies(page_list)
@@ -24,7 +27,16 @@ module Spontaneous
       end
 
       def export
-        outstanding.map { |change_set| change_set.export }
+        exported = {}
+        outstanding.each do |k, v|
+          case k
+          when :changes
+            exported[k] = v.map { |change_set| change_set.export }
+          else
+            exported[k] = v
+          end
+        end
+        exported
       end
 
       def serialise_http(user = nil)
@@ -61,19 +73,21 @@ module Spontaneous
         :url => page.path,
         :side_effects => export_side_effects(page),
         :published_at => export_timestamp(page.last_published_at),
-        :modified_at => export_timestamp(page.modified_at) }
+        :modified_at => export_timestamp(page.modified_at),
+        :update_locks => export_update_locks(page) }
+    end
+
+    def export_update_locks(page)
+      keys = [:id, :content_id, :field_id, :field_name, :location, :description, :created_at]
+      page.update_locks.map { |lock| export_object(lock, keys) }
     end
 
     def export_side_effects(page)
-    side_effects = Hash.new { |h, k| h[k] = [] }
-       page.pending_modifications.map do |modification|
-         side_effects[modification.type] << {
-           :count => modification.count,
-           :created_at => export_timestamp(modification.created_at),
-           :old_value => modification.old_value,
-           :new_value => modification.new_value
-         }
-      end
+      keys = [:count, :created_at, :old_value, :new_value]
+      side_effects = Hash.new { |h, k| h[k] = [] }
+      page.pending_modifications.map { |modification|
+        side_effects[modification.type] << export_object(modification, keys)
+      }
       side_effects
     end
 
@@ -95,5 +109,17 @@ module Spontaneous
     def inspect
       %(#<Spontaneous::Change page=#{page.id} dependent=#{dependent.map(&:id).inspect}>)
     end
+
+    def export_object(target, keys)
+      translate = proc { |value|
+        case value
+        when Time, Date
+          export_timestamp(value)
+        else
+          value
+        end
+      }
+      Hash[ keys.map { |k| [k, translate[target.send(k)] ] } ]
+    end
   end
 end

data/lib/spontaneous/cli/fields.rb

@@ -0,0 +1,29 @@
+
+module Spontaneous
+  module Cli
+    class Fields < ::Thor
+      include Spontaneous::Cli::TaskUtils
+      include ::Simultaneous::Task
+
+      namespace :fields
+
+      desc "update", "Performs asynchronous updates on provided fields"
+      method_option :fields, :type => :array, :desc => "List of field IDs to update"
+      def update
+        prepare! :update, :console
+        fields = Spontaneous::Field.find(*options.fields)
+        updater = Spontaneous::Field::Update::Immediate.new(fields)
+        updater.run
+        send_completion_event(updater)
+      end
+
+      private
+
+      def send_completion_event(updater)
+        unlocked_pages = updater.pages.reject { |p| p.locked_for_update? }
+        simultaneous_event('page_lock_status', unlocked_pages.map(&:id).to_json)
+      end
+    end
+  end
+end
+

data/lib/spontaneous/cli/init.rb

@@ -29,7 +29,7 @@ module Spontaneous::Cli
       [database, "#{database}_test"].each do |db|
         config = site_connection_params.merge(:database => db)
         create(db, admin_connection_params, config)
-        migrate(db, admin_connection_params, config)
+        migrate(db, site_connection_params, config)
       end
 
       boot!
@@ -102,7 +102,7 @@ module Spontaneous::Cli
                 when :postgres
                   [
                     [%(CREATE ROLE "#{config[:user]}" LOGIN PASSWORD '#{config[:password]}'), false],
-                    [%(CREATE DATABASE "#{config[:database]}" TEMPLATE=template0 ENCODING='UTF8' OWNER="#{config[:user]}"), true]
+                    [%(CREATE DATABASE "#{config[:database]}" WITH TEMPLATE=template0 ENCODING='UTF8' LC_COLLATE='C.UTF-8' LC_CTYPE='C.UTF-8' OWNER="#{config[:user]}"), true]
                   ]
                 when :mysql
                   host = config[:host].blank? ? "" : "@#{config[:host]}"

data/lib/spontaneous/cli/migrate.rb

@@ -17,6 +17,5 @@ module Spontaneous::Cli
       Sequel::Migrator.apply(Spontaneous.database, ::Spontaneous.gem_dir('db/migrations'))
       say "  >> Done"
     end
-
   end # Migrate
 end # Spontaneous::Cli

data/lib/spontaneous/cli/server.rb

@@ -16,14 +16,7 @@ module Spontaneous
 
       desc "start", "Starts Spontaneous in development mode"
       def start
-        root   = File.expand_path(options.site)
-        engine = ::Foreman::Engine::CLI.new(root: options.site)
-
-        %w(back front publish).each do |process|
-          engine.register(process, "#{binary} server #{process} --root=#{root}")
-        end
-
-        engine.start
+        launch %w(back front tasks)
       end
 
       desc "front", "Starts Spontaneous in front/public mode"
@@ -47,15 +40,26 @@ module Spontaneous
       def simultaneous
         prepare! :start
         connection = options[:connection] || ::Spontaneous.config.simultaneous_connection
-        exec({"BUNDLE_GEMFILE" => nil}, "#{Simultaneous.server_binary} -c #{connection} --debug")
+        exec({"BUNDLE_GEMFILE" => nil}, "#{::Simultaneous.server_binary} -c #{connection} --debug")
       end
 
       # A shorter name for the 'simultaneous' task is useful (Foreman appends
       # it to each line of output)
-      map %w(bg publish) => :simultaneous
+      map %w(bg publish tasks) => :simultaneous
 
       private
 
+      def launch(processes)
+        root   = File.expand_path(options.site)
+        engine = ::Foreman::Engine::CLI.new(root: options.site)
+
+        processes.each do |process|
+          engine.register(process, "#{binary} server #{process} --root=#{root}")
+        end
+
+        engine.start
+      end
+
       def binary
         ::Spontaneous.gem_dir("bin/spot")
       end

data/lib/spontaneous/cli/site.rb

@@ -1,9 +1,11 @@
 require 'spontaneous/cli'
+require 'simultaneous'
 
 module Spontaneous
   module Cli
     class Site < ::Thor
       include Spontaneous::Cli::TaskUtils
+      include ::Simultaneous::Task
       namespace :site
 
       default_task :browse
@@ -116,37 +118,46 @@ module Spontaneous
       method_option :logfile, :type => :string, :desc => "Location of logfile"
       def publish
         prepare! :publish
-        ::Site.publishing_method = :immediate
+        Spontaneous::Site.background_mode = :immediate
         ::Spontaneous::Logger.setup(:logfile => options.logfile) if options.logfile
-        say "Creating revision #{::Site.revision}", :green, true
+        say "Creating revision #{Spontaneous::Site.revision}", :green, true
         if options.pages
           say ">  Publishing pages #{options.pages.inspect}", :green, true
-          ::Site.publish_pages(options.pages)
+          Spontaneous::Site.publish_pages(options.pages)
         else
           say ">  Publishing all", :green, true
-          ::Site.publish_all
+          Spontaneous::Site.publish_all
         end
+        # Rescue all errors to feed back to the UI
+      rescue ::Exception => e
+        send_error_notification(e)
       end
 
       desc "render", "Re-renders the current content"
       def render
         prepare! :render
-        ::Site.publishing_method = :immediate
-        ::Site.rerender
+        Spontaneous::Site.background_mode = :immediate
+        Spontaneous::Site.rerender
       end
 
       desc "revision", "Shows the site status"
       def revision
         prepare! :revision
-        say "Site is at revision #{::Site.revision}", :green
+        say "Site is at revision #{Spontaneous::Site.revision}", :green
       end
 
-      desc "browse", "Launces a browser pointing to the current development CMS"
+      desc "browse", "Launches a browser pointing to the current development CMS"
       def browse
         prepare :browse
         require 'launchy'
         boot!
-        ::Launchy.open("http://localhost:#{::Site.config.port}/@spontaneous")
+        ::Launchy.open("http://localhost:#{Spontaneous::Site.config.port}/@spontaneous")
+      end
+
+      private
+
+      def send_error_notification(error)
+        simultaneous_event('publish_progress', {:state => "error", :progress => error}.to_json)
       end
     end
   end

data/lib/spontaneous/cli.rb

@@ -83,16 +83,17 @@ module Spontaneous
       end
     end
 
+    autoload :Assets,   "spontaneous/cli/assets"
     autoload :Console,  "spontaneous/cli/console"
-    autoload :Site,     "spontaneous/cli/site"
-    autoload :Init,     "spontaneous/cli/init"
-    autoload :User,     "spontaneous/cli/user"
+    autoload :Fields,   "spontaneous/cli/fields"
     autoload :Generate, "spontaneous/cli/generate"
-    autoload :Server,   "spontaneous/cli/server"
+    autoload :Init,     "spontaneous/cli/init"
     autoload :Media,    "spontaneous/cli/media"
-    autoload :Sync,     "spontaneous/cli/sync"
     autoload :Migrate,  "spontaneous/cli/migrate"
-    autoload :Assets,   "spontaneous/cli/assets"
+    autoload :Server,   "spontaneous/cli/server"
+    autoload :Site,     "spontaneous/cli/site"
+    autoload :Sync,     "spontaneous/cli/sync"
+    autoload :User,     "spontaneous/cli/user"
 
     class Root < ::Thor
       register Spontaneous::Cli::Console,  "console",  "console",           "Gives you console access to the current site"
@@ -105,6 +106,7 @@ module Spontaneous
       register Spontaneous::Cli::Sync,     "sync",     "sync [DIRECTION]",  "Sync database and media to and from the production server"
       register Spontaneous::Cli::Migrate,  "migrate",  "migrate",           "Runs Spontaneous migrations"
       register Spontaneous::Cli::Assets,   "assets",   "assets [ACTION]",   "Manage Spontaneous assets"
+      register Spontaneous::Cli::Fields,   "fields",   "fields [ACTION]",   "Manage Spontaneous fields"
 
       desc :browse, "Launces a browser pointing to the current development CMS"
       def browse

data/lib/spontaneous/collections/box_set.rb

@@ -37,6 +37,17 @@ module Spontaneous::Collections
       self.select { |box| box._prototype.group == group_name }
     end
 
+    # A call to ${ content } within a layout template will call
+    # this #render method. The obvious result of this should be
+    # to just render each of the contained boxes.
+    def render(format = :html, params = {}, *args)
+      map { |box| box.render(format, params, *args) }.join("\n")
+    end
+
+    def render_using(renderer, format = :html, params = {}, *args)
+      map { |box| box.render_using(renderer, format, params, *args) }.join("\n")
+    end
+
     protected
 
     def get_single(index)

data/lib/spontaneous/collections/field_set.rb

@@ -32,8 +32,31 @@ module Spontaneous::Collections
       super || load_field(owner.field_prototypes[name.to_sym])
     end
 
+    # A call to ${ fields } within a template will call
+    # this #render method.
+    # This should only be used during development
+    #
+    def render(format = :html, params = {}, *args)
+      map { |field| wrap_field_value(field, field.render(format, params, *args), format) }.join("\n")
+    end
+
+    def render_using(renderer, format = :html, params = {}, *args)
+      map { |field| wrap_field_value(field, field.render_using(renderer, format, params, *args), format) }.join("\n")
+    end
+
     protected
 
+    def wrap_field_value(field, value, format)
+      case format
+      when "html", :html
+        classes = [owner.class.to_s.dasherize.downcase, "field", field.name].join(" ")
+        id = "field-#{field.id.gsub(/\//, "-")}"
+        [ %(<div class="#{classes}" id="#{id}">), value, "</div>" ].join
+      else
+        value
+      end
+    end
+
     def initialize_from_prototypes
       owner.field_prototypes.each do |field_prototype|
         add_field(field_prototype)
@@ -46,7 +69,7 @@ module Spontaneous::Collections
 
     def parse_field_data(initial_values)
       values = (initial_values || []).map do |value|
-        value = S::FieldTypes.deserialize_field(value)
+        value = S::Field.deserialize_field(value)
         [Spontaneous.schema.uids[value[:id]], value]
       end
       Hash[values]