spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/page_lock.rb

@@ -6,9 +6,6 @@ module Spontaneous
 
     plugin :timestamps
 
-    many_to_one :page, :class => "Spontaneous::Content", :key => :page_id
-    many_to_one :content, :class => "Spontaneous::Content", :key => :content_id
-
     def self.lock_field(field)
       create(field_attributes(field).merge(
         :description => field.page_lock_description
@@ -40,7 +37,7 @@ module Spontaneous
     end
 
     def field
-      @field ||= Spontaneous::Field.find(field_id)
+      @field ||= Spontaneous::Field.find(content.model, field_id)
     end
 
     def field_name
@@ -49,12 +46,13 @@ module Spontaneous
 
     def location
       field, owner = self.field, self.field.owner
+      model = owner.model.content_model
       case owner
-      when Spontaneous::Content::Box
+      when model::Box
         "Field ‘#{field.name}’ of box ‘#{owner.box_name}’"
-      when Spontaneous::Content::Page
+      when model::Page
         "Field ‘#{field.name}’"
-      when Spontaneous::Content::Piece
+      when model::Piece
         "Field ‘#{field.name}’ of entry #{owner.position + 1} in box ‘#{owner.container.box_name}’"
       end
     end

data/lib/spontaneous/page_piece.rb

@@ -72,8 +72,8 @@ module Spontaneous
       target.resolve_style(style_id)
     end
 
-    def template(format = :html)
-      style.template(format)
+    def template(format = :html, renderer = Spontaneous::Output.default_renderer)
+      style.template(format, renderer)
     end
   end
 end

data/lib/spontaneous/permissions/user.rb

@@ -10,7 +10,7 @@ module Spontaneous::Permissions
     many_to_many :groups,       :class => :'Spontaneous::Permissions::AccessGroup', :join_table => :spontaneous_groups_users
     one_to_many  :access_keys,  :class => :'Spontaneous::Permissions::AccessKey', :reciprocal => :user
 
-    set_restricted_columns(:crypted_password)
+    set_allowed_columns(:name, :login, :email, :disabled, :password, :level)
 
     def_delegators :group, :level, :access_selector
 
@@ -188,17 +188,24 @@ module Spontaneous::Permissions
       errors.add(:email, 'is required') if email.blank?
       errors.add(:email, 'is invalid')  unless email.blank? or email =~ /\A[^@]+@.+\z/
 
-      if login.blank?
-        errors.add(:login, 'is required')
-      else
-        errors.add(:login, 'should only contain letters, numbers & underscore') unless login =~ /\A[a-zA-Z0-9_]+\z/
-        errors.add(:login, 'should be at least 3 letters long') if login.length < 3
-      end
+      validate_login
+      validate_login_uniqueness
+      validate_password
+    end
 
+    def validate_login
+      return errors.add(:login, 'is required') if login.blank?
+      errors.add(:login, 'should only contain letters, numbers & underscore') unless login =~ /\A[a-zA-Z0-9_]+\z/
+      errors.add(:login, 'should be at least 3 letters long') if login.length < 3
+    end
+
+    def validate_login_uniqueness
       if (u = User[:login => login]) && (u.id != id)
         errors.add(:login, "must be unique, login '#{login}' already exists")
       end
+    end
 
+    def validate_password
       if new? || updating_password?
         if password.blank?
           errors.add(:password, 'is required')

data/lib/spontaneous/plugins/application/features.rb

@@ -5,12 +5,16 @@ module Spontaneous::Plugins::Application
     extend Spontaneous::Concern
 
     module ClassMethods
-      def register_back_controller(namespace, controller_class)
-        instance.register_back_controller(namespace, controller_class)
+      def register_back_controller(namespace, controller_class, opts = {})
+        instance.register_back_controller(namespace, controller_class, opts)
       end
 
-      def register_front_controller(namespace, controller_class)
-        instance.register_front_controller(namespace, controller_class)
+      def register_front_controller(namespace, controller_class, opts = {})
+        instance.register_front_controller(namespace, controller_class, opts)
+      end
+
+      def front
+        instance.front
       end
     end # ClassMethods
   end # Features

data/lib/spontaneous/plugins/application/state.rb

@@ -24,6 +24,7 @@ module Spontaneous::Plugins::Application
             "   'auto_login' setting from your environment file."
           end
           Thread.current[:spontaneous_loaded] = true
+          site
         end
       end
 
@@ -39,7 +40,7 @@ module Spontaneous::Plugins::Application
       # a nice way to create the ::Site constant in the user/site code
       def site(content_model)
         site!(content_model) unless defined?(Spontaneous::Content)
-        Spontaneous::Site
+        Spontaneous::Site.instance
       end
 
       # This forces the assignment of Spontaneous::Content, overwriting any
@@ -48,10 +49,11 @@ module Spontaneous::Plugins::Application
       # Used in tests.
       #
       def site!(content_model)
-        spot = ::Spontaneous
-        Spontaneous.send :remove_const, :Content if defined?(Spontaneous::Content)
-        Spontaneous.const_set(:Content, content_model)
-        Spontaneous::Site
+        site = Spontaneous::Site.instance
+        # Spontaneous.send :remove_const, :Content if defined?(Spontaneous::Content)
+        # Spontaneous.const_set(:Content, content_model)
+        site.model = content_model
+        site
       end
 
       def loaded?
@@ -59,8 +61,12 @@ module Spontaneous::Plugins::Application
       end
 
 
+      def instance
+        Spontaneous::Site.instance
+      end
+
       def config
-        Spontaneous::Site.instance.config
+        instance.config
       end
 
       def db_settings

data/lib/spontaneous/prototypes/box_prototype.rb

@@ -176,19 +176,18 @@ module Spontaneous::Prototypes
     end
 
     def allowed_types(user)
-      if writable?(user)
-        types = []
-        instance_class.allowed.select { |a| a.readable?(user) }.each do  |a|
-          types.concat(a.instance_classes)
-        end
-        types
-      else
-        []
-      end
+      _allowed(user).flat_map { |allow| allow.instance_classes }
     end
 
+    def _allowed(user)
+      return [] unless writable?(user)
+      instance_class.allowed.select { |a| a.readable?(user) }
+    end
+
+    private :_allowed
+
     def export(user)
-      allowed = allowed_types(user).map { |c| c.ui_class }
+      allowed = _allowed(user).flat_map { |a| a.export }
       {
         :name => name.to_s,
         :id => schema_id.to_s,

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -2,6 +2,49 @@
 
 
 module Spontaneous::Prototypes
+  # FieldPrototype represents the class-level view of a type field.
+  # It contains information on the type of the field and the options
+  # passed in the type declaration and is responsible for transforming
+  # serialized field data from the db into a field instance.
+  #
+  # options - A hash containing options that control the behaviour of the
+  #           field (default: {})
+  #
+  #           :default  - The default value for new fields. This accepts either a
+  #                       value (which is either a String or responds to #to_s)
+  #                       or a Proc value generator which can accept 1 argument
+  #                       that is the instance that the field is attached to.
+  #           :title    - The title that should be used to label the field in the UI.
+  #                       This defaults to the 'titleized' version of the field name,
+  #                       e.g. ':field_name' becomes 'Field Name'.
+  #           :comment  - An optional String comment to be displayed in the UI
+  #                       (default: "").
+  #           :list     - A Boolean flag determining whether to show the field in the
+  #                       list view (default: true).
+  #           :fallback - Provides a way of supplying a fallback value for an empty
+  #                       field.
+  #
+  #           Other options are dependent on the type of field.
+  #
+  # Examples
+  #
+  # Pass a Proc as the default value for a field:
+  #
+  #   field :title, default: proc { |page| "This is page #{page.slug}" }
+  #
+  # Assign a field with a fallback:
+  #
+  #   class Something < Piece
+  #     field :a
+  #     field :b, fallback: :a
+  #   end
+  #
+  #   instance = Something.new(a: "The value of A")
+  #   instance.a.value #=> "The value of A"
+  #   instance.b.value #=> "The value of A"
+  #   instance.b = "Now B"
+  #   instance.b.value #=> "Now B"
+  #
   class FieldPrototype
     attr_reader :owner, :name, :options
 
@@ -59,7 +102,7 @@ module Spontaneous::Prototypes
     end
 
     def default_options(field_class)
-      {:default => '', :comment => false }.merge(field_class.default_options)
+      {default: '', comment: false, list: true}.merge(field_class.default_options)
     end
 
     def instance_class
@@ -116,19 +159,26 @@ module Spontaneous::Prototypes
     end
 
     def in_index?(index)
-      search.in_index?(index)
+      search(index.site).in_index?(index)
     end
 
     def index_id(index)
-      search.index_id(index)
+      search(index.site).index_id(index)
     end
 
     def options_for_index(index)
-      search.field_definition(index)
+      search(index.site).field_definition(index)
     end
 
-    def search
-      @search ||= S::Search::Field.new(self, @options[:index])
+    # TODO: it's wrong to have to be passing the site to this call
+    # as there's only ever one site and we shouldn't be memoizing
+    # a method call with a param.
+    # Must centralize the testing of a prototype for inclusion into
+    # an index - either into the index or the site itself.
+    # We can't just recalculate this on the fly because indexing
+    # needs to be reasonably performant.
+    def search(site)
+      @search ||= S::Search::Field.new(site, self, @options[:index])
     end
 
     def inherit_schema_id(schema_id)
@@ -148,19 +198,20 @@ module Spontaneous::Prototypes
       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
+      field = self.instance_class.new(values, using_default_values)
+      field.prototype = self
+      field
     end
 
     def export(user)
       {
-        :name => name.to_s,
-        :schema_id => schema_id.to_s,
-        :type => instance_class.editor_class,
-        :title => title,
-        :comment => comment || "",
-        :writable => Spontaneous::Permissions.has_level?(user, write_level)
+        name: name.to_s,
+        schema_id: schema_id.to_s,
+        type: instance_class.editor_class,
+        title: title,
+        comment: comment || "",
+        list: @options[:list] || false,
+        writable: Spontaneous::Permissions.has_level?(user, write_level)
       }.merge(instance_class.export(user))
     end
   end

data/lib/spontaneous/publishing/immediate.rb

@@ -12,14 +12,14 @@ module Spontaneous
 
       attr_reader :revision, :now
 
-      def initialize(revision, content_model)
-        @revision, @content_model = revision, content_model
-        @previous_revision = Spontaneous::Site.published_revision
+      def initialize(site, revision)
+        @site, @revision, @content_model = site, revision, site.model
+        @previous_revision = @site.published_revision
         @now = Time.now
       end
 
       def renderer
-        @renderer ||= Spontaneous::Output::Template::PublishRenderer.new(true)
+        @renderer ||= Spontaneous::Output::Template::PublishRenderer.new(@site, true)
       end
 
       def publish_pages(page_list)
@@ -71,14 +71,14 @@ module Spontaneous
 
 
       def pages
-        @pages ||= Spontaneous::Site.pages(@content_model)
+        @pages ||= @site.pages
       end
 
       # The number of times the publisher has to run through the site's pages
       # in order to generate the search indexes.
       # Returns either 0 or 1
       def index_stages
-        [1, S::Site.indexes.length].min
+        [1, @site.indexes.length].min
       end
 
       def publish(modified_page_list)
@@ -97,7 +97,6 @@ module Spontaneous
       end
 
       def render_revision
-        S::Output.renderer = renderer
         update_progress("rendering", 0)
         @pages_rendered = 0
         @content_model.scope(@revision, true) do
@@ -109,24 +108,27 @@ module Spontaneous
       end
 
       def render_pages
-        # the delay is purely used in interface testing
-        delay = Spontaneous::Site.config.publishing_delay
+        template_revision = @site.output_store.revision(@revision)
+        @render_transaction = template_revision.transaction
+        delay = @site.config.publishing_delay # the delay is purely used in interface testing
         pages.each do |page|
           page.outputs.each do |output|
-            render_page(page, output)
+            render_page(page, output, @render_transaction)
           end
           sleep(delay) if delay
         end
+        @render_transaction.commit
+        @render_transaction = nil
       end
 
-      def render_page(page, output)
+      def render_page(page, output, transaction)
         logger.info { "#{page.path}" }
-        output.publish_page(renderer, revision)
+        output.publish_page(renderer, revision, transaction)
         page_rendered(page, "rendering", output.format)
       end
 
       def index_pages
-        S::Site.indexer(revision) do |indexer|
+        @site.indexer(revision) do |indexer|
           pages.each { |page|
             indexer << page
             page_rendered(page, 'indexing')
@@ -283,7 +285,7 @@ module Spontaneous
         # when working with multiple instances it's possible to rollback the revision number
         # leaving behind old revisions > the current published_revision.
         @content_model.delete_revision(revision)
-        Spontaneous::Site.send(:pending_revision=, revision)
+        @site.send(:pending_revision=, revision)
       end
 
       def after_publish
@@ -292,28 +294,29 @@ module Spontaneous
           tmp = Spontaneous.revision_dir(revision) / "tmp"
           FileUtils.mkdir_p(tmp) unless ::File.exists?(tmp)
           activate_revision
+          @site.must_publish_all!(false)
           update_progress("complete")
         rescue => e
           # if a post publish hook raises an exception then we want to roll everything back
-          deactivate_revision
+          deactivate_revision(e)
           raise e
         end
       end
 
       def activate_revision
         S::PublishedRevision.create(:revision => revision, :published_at => now)
-        Spontaneous::Site.send(:set_published_revision, revision)
+        @site.send(:set_published_revision, revision)
         write_revision(revision)
-        Spontaneous::Site.trigger(:after_publish, revision)
-        Spontaneous::Site.send(:pending_revision=, nil)
-        Spontaneous::Content.cleanup_revisions(revision, keep_revisions)
+        @site.trigger(:after_publish, revision)
+        @site.send(:pending_revision=, nil)
+        @content_model.cleanup_revisions(revision, keep_revisions)
       end
 
-      def deactivate_revision
+      def deactivate_revision(exception)
         S::PublishedRevision.filter(:revision => revision).delete
-        Spontaneous::Site.send(:set_published_revision, @previous_revision)
+        @site.send(:set_published_revision, @previous_revision)
         write_revision(@previous_revision)
-        abort_publish(e)
+        abort_publish(exception)
       end
 
       # Makes the revision live on the filesystem by symlinking the revisions/current
@@ -333,17 +336,18 @@ module Spontaneous
       end
 
       def abort_publish(exception)
-        if (r = S::Site.pending_revision)
+        if (r = @site.pending_revision)
           update_progress("aborting")
-          FileUtils.rm_r(Spontaneous.revision_dir(revision)) if File.exists?(Spontaneous.revision_dir(revision))
-          Spontaneous::Site.send(:pending_revision=, nil)
+          @render_transaction.rollback if @render_transaction
+          @site.output_store.revision(r).delete # we might have committed the transaction
+          @site.send(:pending_revision=, nil)
           @content_model.delete_revision(revision)
           puts exception.backtrace.join("\n") if exception
         end
       end
 
       def keep_revisions
-        Spontaneous::Site.config.keep_revisions || KEEP_REVISIONS
+        @site.config.keep_revisions || KEEP_REVISIONS
       end
     end # Immediate
   end # Publishing