spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/page_lock.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class PageLock < Sequel::Model(:spontaneous_page_lock)
+    class InvalidPage < Spontaneous::Error; end
+
+    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
+      ))
+    rescue InvalidPage
+      nil
+    end
+
+    def self.unlock_field(field)
+      field_dataset(field).delete
+    rescue InvalidPage
+      nil
+    end
+
+    def self.field_dataset(field)
+      filter(field_attributes(field))
+    end
+
+    def self.field_attributes(field)
+      owner = field.owner
+      raise InvalidPage.new(field.id) unless owner.page
+      { :content_id => owner.content_instance.id,
+        :page_id    => owner.page.id,
+        :field_id   => field.id }
+    end
+
+    def field=(field)
+      self.field_id = field.id
+    end
+
+    def field
+      @field ||= Spontaneous::Field.find(field_id)
+    end
+
+    def field_name
+      field.name
+    end
+
+    def location
+      field, owner = self.field, self.field.owner
+      case owner
+      when Spontaneous::Content::Box
+        "Field ‘#{field.name}’ of box ‘#{owner.box_name}’"
+      when Spontaneous::Content::Page
+        "Field ‘#{field.name}’"
+      when Spontaneous::Content::Piece
+        "Field ‘#{field.name}’ of entry #{owner.position + 1} in box ‘#{owner.container.box_name}’"
+      end
+    end
+  end
+end

data/lib/spontaneous/page_piece.rb

@@ -4,7 +4,7 @@ require 'delegate'
 
 module Spontaneous
   class PagePiece < DelegateClass(Page)
-    include Plugins::Render
+    include Spontaneous::Model::Core::Render
 
     attr_accessor :owner
     attr_reader   :style_id

data/lib/spontaneous/permissions/access_key.rb

@@ -3,7 +3,7 @@
 module Spontaneous::Permissions
   class AccessKey < Sequel::Model(:spontaneous_access_keys)
     plugin :timestamps
-    many_to_one :user, :class => :'Spontaneous::Permissions::User'
+    many_to_one :user, :class => :'Spontaneous::Permissions::User', :reciprocal => :access_keys
 
     def self.authenticate(key_id, ip_address = nil)
       if key = self.for_id(key_id)
@@ -14,12 +14,17 @@ module Spontaneous::Permissions
     end
 
     def self.valid?(key_id, user)
-      return true if (key = self.for_id(key_id)) && (key.user == user) && (key.user.enabled?)
-      false
+      (key = self.for_id(key_id)) && (key.user == user) && (key.user.enabled?)
     end
 
     def self.for_id(key_id)
-      self[:key_id => key_id]
+      key_dataset.call(:key_id => key_id).first
+    end
+
+    def self.key_dataset
+      @key_dataset ||= self.where(:key_id => :$key_id).
+        eager_graph(:user).
+        prepare(:select, :select_access_key_by_key)
     end
 
     def before_create

data/lib/spontaneous/permissions/user.rb

@@ -8,20 +8,27 @@ module Spontaneous::Permissions
 
     one_to_one   :group,        :class => :'Spontaneous::Permissions::AccessGroup'
     many_to_many :groups,       :class => :'Spontaneous::Permissions::AccessGroup', :join_table => :spontaneous_groups_users
-    one_to_many  :access_keys,  :class => :'Spontaneous::Permissions::AccessKey'
+    one_to_many  :access_keys,  :class => :'Spontaneous::Permissions::AccessKey', :reciprocal => :user
 
-    set_restricted_columns(:crypted_password, :salt)
+    set_restricted_columns(:crypted_password)
 
     def_delegators :group, :level, :access_selector
 
-    def self.encrypt_password(clear_password, salt)
-      Digest::SHA1.hexdigest("--#{salt}--#{clear_password}--")
+    def self.login(login)
+      login_dataset.call(:login => login).first
+    end
+
+    def self.login_dataset
+      @login_dataset ||= self.where(:login => :$login).
+        eager_graph(:access_keys).
+        prepare(:select, :select_user_by_login)
     end
 
     def self.authenticate(login, clear_password, ip_address = nil)
-      if user = self[:login => login, :disabled => false]
-        crypted_password = user.encrypt_password(clear_password)
-        if crypted_password == user.crypted_password
+      if (user = self[:login => login, :disabled => false])
+        authenticator = Spontaneous::Crypt.new(clear_password, user.crypted_password)
+        if authenticator.valid?
+          user.upgrade_authentication(authenticator) if authenticator.outdated?
           access_key = user.logged_in!(ip_address)
           return access_key
         end
@@ -91,11 +98,14 @@ module Spontaneous::Permissions
     end
 
     def encrypt_password(clear_password)
-      self.class.encrypt_password(clear_password, salt)
+      Spontaneous::Crypt.hash(clear_password)
+    end
+
+    def upgrade_authentication(auth)
+      update_all :crypted_password => auth.upgrade
     end
 
     def before_save
-      self.salt = Spontaneous::Permissions.random_string(32) if salt.blank?
       self.crypted_password = encrypt_password(password) unless password.blank?
       clear_access_keys! if disabled?
       super

data/lib/spontaneous/permissions.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 
 require 'base58'
+require 'securerandom'
 
 module Spontaneous
   module Permissions
@@ -10,8 +11,6 @@ module Spontaneous
     autoload :AccessGroup, "spontaneous/permissions/access_group"
     autoload :AccessKey, "spontaneous/permissions/access_key"
 
-    @@active_user = nil
-
     class << self
       # Convenience shortcut so we can do Permissions[:root]
       def [](level_name)
@@ -28,9 +27,7 @@ module Spontaneous
       end
 
       def random_string(length)
-        bytes = ((length * Math.log10(58))/(8 * Math.log10(2))).ceil + 2
-        string = Base58.encode(OpenSSL::Random.random_bytes(bytes).unpack("h*").first.to_i(16))
-        string[0...(length)]
+        SecureRandom.urlsafe_base64(length)[0...(length)]
       end
     end
   end

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

@@ -2,7 +2,7 @@
 
 module Spontaneous::Plugins::Application
   module Facets
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def instance
@@ -16,7 +16,6 @@ module Spontaneous::Plugins::Application
       def schema
         instance.schema
       end
-
     end
   end
 end

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

@@ -2,7 +2,7 @@
 
 module Spontaneous::Plugins::Application
   module Features
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def register_back_controller(namespace, controller_class)

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

@@ -2,7 +2,7 @@
 
 module Spontaneous::Plugins::Application
   module Paths
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def load_paths

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

@@ -4,7 +4,7 @@ require 'cutaneous'
 
 module Spontaneous::Plugins::Application
   module Render
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       attr_accessor :render_engine

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

@@ -2,7 +2,7 @@
 
 module Spontaneous::Plugins::Application
   module Serialisation
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       include Spontaneous::JSON

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

@@ -2,7 +2,7 @@
 
 module Spontaneous::Plugins::Application
   module State
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def init(options={})
@@ -11,6 +11,8 @@ module Spontaneous::Plugins::Application
         self.mode = options.delete(:mode) || ENV["SPOT_MODE"] || :back
         root = options.delete(:root) || ENV["SPOT_ROOT"] || Dir.pwd
         site = Spontaneous::Site.instantiate(root, environment, mode)
+        lib = File.expand_path(File.join(root, "lib"))
+        $:.push(lib) unless $:.include?(lib)
         Spontaneous::Logger.setup(:log_level => options[:log_level], :logfile => options[:logfile], :cli => options[:cli])
         site.initialize!
         site.schema.validate! if self.mode == :console
@@ -18,6 +20,33 @@ module Spontaneous::Plugins::Application
         Thread.current[:spontaneous_loaded] = true
       end
 
+      # This is called after definition of the Content model.
+      #
+      #   Site = Spontaneous.site(Content)
+      #
+      # It is a safe way to define the content model that should be used
+      # globally as it checks for its existance before overwriting.
+      #
+      # I could do the assignment of Spontaneous::Content automatically
+      # after creation of the first content model, but this method provides
+      # 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
+      end
+
+      # This forces the assignment of Spontaneous::Content, overwriting any
+      # previous value.
+      #
+      # 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
+      end
+
       def loaded?
         Thread.current[:spontaneous_loaded]
       end

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

@@ -4,31 +4,31 @@ require 'fiber'
 
 module Spontaneous::Plugins::Application
   module System
-    extend ActiveSupport::Concern
+    extend Spontaneous::Concern
 
     module ClassMethods
       def async?
         defined?(::EM) && ::EM.reactor_running?
       end
 
-      def system(cmd, timeout = 10)
-        return async_system(cmd) if async?
-        super(cmd)
+      def system(cmd, timeout = 10, &callback)
+        if async?
+          async_system(cmd, &callback)
+        else
+          result = super(cmd)
+          callback.call(result) if callback
+        end
       end
 
-      # Invokes an asynchronous system call. Must be wrapped in a Fiber
-      # such as that provided by rack-fiber_pool
-      def async_system(cmd, timeout = 10)
+      # Invokes an asynchronous system call
+      def async_system(cmd, timeout = 10, &callback)
         deferrable = EM::DefaultDeferrable.new
-        fiber = Fiber.current
         EM.system cmd do |output, status|
-          deferrable.succeed
-          fiber.resume [output, status]
+          deferrable.succeed(output, status)
         end
         deferrable.timeout timeout
         deferrable.errback {  }
-        output, status = Fiber.yield
-        status.success?
+        deferrable.callback(&callback)
       end
     end
   end

data/lib/spontaneous/prototypes/box_prototype.rb

@@ -114,7 +114,7 @@ module Spontaneous::Prototypes
     end
 
     def default_box_class
-      defined?(::Box) ? ::Box : Spontaneous::Box
+      defined?(::Box) ? ::Box : owner.content_model::Box
     end
 
     ## failed attempt to exclude anonymous boxes from the list of schema classes

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -14,7 +14,7 @@ module Spontaneous::Prototypes
 
       # if the type is nil then try the name, this will assign sensible defaults
       # to fields like 'image' or 'date'
-      @base_class = Spontaneous::FieldTypes[type || name]
+      @base_class = Spontaneous::Field[type || name]
 
       owner.const_set("#{name.to_s.camelize}Field", instance_class)
 
@@ -25,11 +25,8 @@ module Spontaneous::Prototypes
       "field/#{owner.schema_id}/#{name}"
     end
 
-    # def schema_id
-    #   Spontaneous.schema.schema_id(self)
-    # end
     def schema_id
-      Spontaneous.schema.uids[@_inherited_schema_id] || Spontaneous.schema.schema_id(self)
+      Spontaneous.schema.uids[@_inherited_schema_id] || Spontaneous.schema.to_id(self)
     end
 
     def schema_owner
@@ -145,7 +142,7 @@ 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|
+      self.instance_class.new(values, using_default_values).tap do |field|
         field.prototype = self
       end
     end

data/lib/spontaneous/prototypes/style_prototype.rb

@@ -29,7 +29,7 @@ module Spontaneous::Prototypes
     end
 
     def schema_id
-      Spontaneous.schema.schema_id(self)
+      Spontaneous.schema.to_id(self)
     end
 
     def export(user)

data/lib/spontaneous/publishing/immediate.rb

@@ -8,11 +8,14 @@ module Spontaneous
     class Immediate
       include ::Simultaneous::Task
 
-      attr_reader :revision
+      KEEP_REVISIONS = 8
 
-      def initialize(revision)
-        @revision = revision
-        @previous_revision = Site.published_revision
+      attr_reader :revision, :now
+
+      def initialize(revision, content_model)
+        @revision, @content_model = revision, content_model
+        @previous_revision = Spontaneous::Site.published_revision
+        @now = Time.now
       end
 
       def renderer
@@ -21,9 +24,9 @@ module Spontaneous
 
       def publish_pages(page_list)
         pages = page_list.flatten.map { |c|
-          c.is_a?(S::Page) ? c.reload : S::Page[c]
+          c.is_a?(@content_model::Page) ? c.reload : @content_model::Page[c]
         }
-        all_pages = S::Page.all
+        all_pages = @content_model::Page.all
 
         if (all_pages - pages).empty?
           # publish_all is quicker
@@ -55,9 +58,7 @@ module Spontaneous
 
       def rerender_revision
         logger.info {  "Re-rendering revision #{@revision}"}
-        S::Content.with_revision(@revision) do
-          render_revision
-        end
+        render_revision
       end
 
       protected
@@ -70,7 +71,7 @@ module Spontaneous
 
 
       def pages
-        @pages ||= S::Page.order(:depth)
+        @pages ||= Spontaneous::Site.pages(@content_model)
       end
 
       # The number of times the publisher has to run through the site's pages
@@ -87,7 +88,7 @@ module Spontaneous
         }
         before_publish
         begin
-          S::Content.publish(revision, modified_page_list) do
+          @content_model.publish(revision, modified_page_list) do
             render_revision
           end
           after_publish
@@ -101,11 +102,9 @@ module Spontaneous
         S::Output.renderer = renderer
         update_progress("rendering", 0)
         @pages_rendered = 0
-        S::Content.with_identity_map do
-          S::Content.with_visible do
-            render_pages
-            index_pages unless index_stages == 0
-          end
+        @content_model.scope(@revision, true) do
+          render_pages
+          index_pages unless index_stages == 0
         end
         copy_static_files
         generate_rackup_file
@@ -138,12 +137,15 @@ module Spontaneous
       end
 
       # Used to calculate the progress percentage
-      # Calculated by (pages * indexes) * (pages * formats)
+      # Calculated by (pages * indexes) + (pages * formats)
       # where indexes = Site.indexes.length > 0 ? 1 : 0
       # 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.outputs.length
+        @total_pages ||= \
+          begin
+            index_steps  = (index_stages * pages.count)
+            output_steps = pages.map { |page| page.outputs.length }.inject(0, :+)
+            index_steps  + output_steps
         end
       end
 
@@ -188,6 +190,15 @@ module Spontaneous
         File.open(rack_file, 'w') { |f| f.write(template) }
       end
 
+      # Creates a revisions/REVISION file that contains the directory name of the current
+      # revision. This is useful in deployment because it's a real (non-symlinked) file
+      # that changes with each publish and can hence be used as the target for an
+      # `inotifywait` script that does something with every publish.
+      def generate_revision_file(r)
+        rev_file = Spontaneous.revision_root / 'REVISION'
+        File.open(rev_file, 'w') { |f| f.write(Spontaneous::Media.pad_revision(r)) }
+      end
+
       def copy_static_files
         update_progress("copying_files")
         public_dest = Pathname.new(Spontaneous.revision_dir(revision) / 'public')
@@ -202,29 +213,34 @@ module Spontaneous
       def copy_facet_public_files(facet, public_dest)
         public_dirs = facet.paths.expanded(:public).map { |dir| Pathname.new(dir) }
         public_dirs.each do |public_src|
-          if public_src.exist?
-            public_src = public_src.realpath
-            Dir[public_src.to_s / "**/*"].each do |src|
-              src = Pathname.new(src)
-              # insert facet namespace in front of path to keep URLs consistent across
-              # the back & front servers
-              dest = [facet.file_namespace, src.relative_path_from(public_src).to_s].compact
-              dest = (public_dest + File.join(dest))
-              if src.directory?
-                dest.mkpath
-              else
-                case src.extname
-                when ".scss"
-                  render_sass_template(src, dest)
-                else
-                  link_file(src, dest)
-                end
-              end
+          next unless public_src.exist?
+          public_src = public_src.realpath
+          Dir[public_src.to_s / "**/*"].each do |src|
+            src = Pathname.new(src)
+            # insert facet namespace in front of path to keep URLs consistent across
+            # the back & front servers
+            dest = [facet.file_namespace, src.relative_path_from(public_src).to_s].compact
+            dest = (public_dest + File.join(dest))
+            if src.directory?
+              dest.mkpath
+            else
+              copy_public_file(src, dest)
             end
           end
         end
       end
 
+      def copy_public_file(src, dest)
+        # TODO: Add coffeescript compilation.
+        # Should be implemented using sprockets
+        case src.extname
+        when ".scss"
+          render_sass_template(src, dest)
+        else
+          link_file(src, dest)
+        end
+      end
+
       def link_file(src, dest)
         src_dev = File::stat(src).dev
         dst_dev = File::stat(File.dirname(dest)).dev
@@ -264,32 +280,41 @@ module Spontaneous
         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)
+        @content_model.delete_revision(revision)
+        Spontaneous::Site.send(:pending_revision=, revision)
       end
 
       def after_publish
         update_progress("finalising")
-        S::Revision.create(:revision => revision, :published_at => Time.now)
-        S::Site.send(:set_published_revision, revision)
+        S::Revision.create(:revision => revision, :published_at => now)
+        Spontaneous::Site.send(:set_published_revision, revision)
         tmp = Spontaneous.revision_dir(revision) / "tmp"
         FileUtils.mkdir_p(tmp) unless ::File.exists?(tmp)
-        symlink_revision(revision)
+        write_revision(revision)
 
         begin
-          S::Site.trigger(:after_publish, revision)
-          S::Site.send(:pending_revision=, nil)
+          Spontaneous::Site.trigger(:after_publish, revision)
+          Spontaneous::Site.send(:pending_revision=, nil)
+          Spontaneous::Content.cleanup_revisions(revision, keep_revisions)
           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)
+          Spontaneous::Site.send(:set_published_revision, @previous_revision)
+          write_revision(@previous_revision)
           abort_publish(e)
           raise e
         end
       end
 
+      # Makes the revision live on the filesystem by symlinking the revisions/current
+      # directory to the revision directory and writing the current revision to the
+      # revisions/REVISION file.
+      def write_revision(revision)
+        symlink_revision(revision)
+        generate_revision_file(revision)
+      end
+
       def symlink_revision(rev)
         system("ln -nsf #{Spontaneous.revision_dir(rev)} #{Spontaneous.revision_dir}")
       end
@@ -302,12 +327,15 @@ module Spontaneous
         if r = S::Site.pending_revision
           update_progress("aborting")
           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)
+          Spontaneous::Site.send(:pending_revision=, nil)
+          @content_model.delete_revision(revision)
           puts exception.backtrace.join("\n") if exception
-          update_progress("error", exception)
         end
       end
+
+      def keep_revisions
+        Spontaneous::Site.config.keep_revisions || KEEP_REVISIONS
+      end
     end # Immediate
   end # Publishing
 end # Spontaneous