spontaneous 0.1.0.alpha1

data/lib/spontaneous/prototypes/box_prototype.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+
+require 'hwia'
+
+module Spontaneous::Prototypes
+  class BoxPrototype
+
+    attr_reader :name, :options, :owner
+
+    def initialize(owner, name, options, &block)
+      @owner = owner
+      @name = name.to_sym
+      @options = options
+      @extend = block
+    end
+
+    def field_prototypes
+      instance_class.field_prototypes
+    end
+
+    def style_prototypes
+      instance_class.style_prototypes
+    end
+
+    def schema_id
+      instance_class.schema_id
+    end
+
+
+    def schema_name
+      instance_class.schema_name
+    end
+
+    def schema_owner
+      owner
+    end
+
+    def owner_sid
+      schema_owner.schema_id
+    end
+
+    def get_instance(owner)
+      instance = instance_class.new(name, self, owner)
+    end
+
+    def field_defaults
+      @options[:fields]
+    end
+
+    def instance_class
+      @_instance_class ||= create_instance_class
+    end
+
+    def create_instance_class
+      Class.new(box_base_class).tap do |instance_class|
+        box_owner = owner
+        box_name = name
+        instance_class.instance_eval do
+          singleton_class.__send__(:define_method, :schema_name) do
+            "box/#{box_owner.schema_id}/#{box_name}"
+          end
+          singleton_class.__send__(:define_method, :schema_owner) do
+            box_owner
+          end
+          singleton_class.__send__(:define_method, :owner_sid) do
+            box_owner.schema_id
+          end
+        end
+        if @extend
+          instance_class.class_eval(&@extend)
+        end
+      end.tap do |klass|
+        # doing this means we get proper names for the anonymous box classes
+        owner.const_set("#{name.to_s.camelize}Box", klass)
+      end
+    end
+
+    def box_base_class
+      box_class = Spontaneous::Box # AnonymousBox
+      class_name = @options[:type] || @options[:class]
+      box_class = class_name.to_s.constantize if class_name
+      # box_class = Class.new(box_class) do
+      #   def self.inherited(subclass)
+      #     subclasses << subclass
+      #   end
+      # end
+      box_class
+    end
+
+    ## failed attempt to exclude anonymous boxes from the list of schema classes
+    ## actually easier to keep them in, despite later problems with UID creation
+    ## because this way their fields & styles are automatically validated
+    # class AnonymousBox < Spontaneous::Box
+    #   def self.schema_class?
+    #     false
+    #   end
+    # end
+
+    def title
+      @options[:title] || default_title
+    end
+
+    def default_style
+      @options[:style]
+    end
+
+    def default_title
+      name.to_s.titleize.gsub(/\band\b/i, '&')
+    end
+
+    def field_prototypes
+      instance_class.field_prototypes
+    end
+
+    # default read level is None, i.e. every logged in user can read the field
+    def read_level
+      level_name = @options[:read_level] || @options[:user_level] || :none
+      Spontaneous::Permissions[level_name]
+    end
+
+    # default write level is the first level above None
+    def write_level
+      level_name = @options[:write_level] || @options[:user_level] || Spontaneous::Permissions::UserLevel.minimum.to_sym
+      Spontaneous::Permissions[level_name]
+    end
+
+    # TODO: must be able to make these into a module
+    def readable?
+      Spontaneous::Permissions.has_level?(read_level)
+    end
+
+    def writable?
+      Spontaneous::Permissions.has_level?(write_level)
+    end
+
+    def style
+      @options[:style]# || name
+    end
+
+    def readable_fields
+      instance_class.readable_fields
+    end
+
+    def allowed_types
+      if writable?
+        types = []
+        instance_class.allowed.select { |a| a.readable? }.each do  |a|
+          types.concat(a.instance_classes)
+        end
+        types
+      else
+        []
+      end
+    end
+
+    def export
+      allowed = allowed_types.map { |c| c.ui_class }
+      {
+        :name => name.to_s,
+        :id => schema_id.to_s,
+        :title => title,
+        :writable => writable?,
+        :allowed_types => allowed,
+        :fields => readable_fields.map { |name| instance_class.field_prototypes[name].export },
+      }
+    end
+  end
+end

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Prototypes
+  class FieldPrototype
+    attr_reader :owner, :name
+
+    def initialize(owner, name, type, options={})
+      @owner = owner
+      @name = name
+      # 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]
+      if block_given?
+        @field_class = Class.new(base_class, &Proc.new)
+        @field_class.singleton_class.send(:define_method, :name) do
+          base_class.name
+        end
+      else
+        @field_class = base_class
+      end
+
+      # @field_class.prototype = self
+      parse_options(options)
+    end
+
+    def schema_name
+      "field/#{owner.schema_id}/#{name}"
+    end
+
+    def schema_id
+      Spontaneous::Schema.schema_id(self)
+    end
+
+    def schema_owner
+      owner
+    end
+
+    def owner_sid
+      schema_owner.schema_id
+    end
+
+    # alias_method :id, :schema_id
+
+    def title(new_title=nil)
+      self.title = new_title if new_title
+      @title || @options[:title] || default_title
+    end
+
+    def title=(new_title)
+      @title = new_title
+    end
+
+    def default_title
+      @name.to_s.titleize
+    end
+
+    def parse_options(options)
+      @options = {
+        :default => '',
+        :comment => false
+      }.merge(options)
+    end
+
+    def field_class
+      @field_class
+    end
+
+    def default
+      @options[:default]
+    end
+
+    def comment
+      @options[:comment]
+    end
+
+
+    # default read level is None, i.e. every logged in user can read the field
+    def read_level
+      level_name = @options[:read_level] || @options[:user_level] || :none
+      Spontaneous::Permissions[level_name]
+    end
+
+    # default write level is the first level above None
+    def write_level
+      level_name = @options[:write_level] || @options[:user_level] || Spontaneous::Permissions::UserLevel.minimum.to_sym
+      Spontaneous::Permissions[level_name]
+    end
+
+    def to_field(values=nil)
+      default_values = values.nil?
+      values = {
+        :name => self.name,
+        :unprocessed_value => default
+      }.merge(values || {})
+      self.field_class.new(values, !default_values).tap do |field|
+        field.prototype = self
+      end
+    end
+
+    def export
+      {
+        :name => name.to_s,
+        :schema_id => schema_id.to_s,
+        :type => field_class.ui_class,
+        :title => title,
+        :comment => comment || "",
+        :writable => Spontaneous::Permissions.has_level?(write_level)
+      }
+    end
+  end
+end

data/lib/spontaneous/prototypes/layout_prototype.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous::Prototypes
+  class LayoutPrototype < StylePrototype
+    def schema_name
+      "layout/#{owner.schema_id}/#{name}"
+    end
+
+    def layout(owner)
+      Spontaneous::Layout.new(owner, self)
+    end
+
+    def formats
+      Spontaneous::Render.formats(self)
+    end
+  end # LayoutPrototype
+end # Spontaneous::Prototypes

data/lib/spontaneous/prototypes/style_prototype.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module Spontaneous::Prototypes
+  class StylePrototype
+    attr_reader :owner, :name, :options
+
+    def initialize(owner, name, options = {})
+      @owner, @name, @options = owner, name, options
+    end
+
+    def default?
+      options[:default]
+    end
+
+    def schema_name
+      "style/#{owner.schema_id}/#{name}"
+    end
+
+    def schema_owner
+      owner
+    end
+
+    def owner_sid
+      schema_owner.schema_id
+    end
+
+    def style(owner)
+      Spontaneous::Style.new(owner, self)
+    end
+
+    def schema_id
+      Spontaneous::Schema.schema_id(self)
+    end
+
+    def export
+      {
+        :name => name.to_s,
+        :schema_id => schema_id.to_s
+      }
+    end
+  end # StylePrototype
+end # Spontaneous::Prototypes

data/lib/spontaneous/proxy_object.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class ProxyObject
+    alias_method :proxy_class, :class
+    alias_method :__class__, :class
+    alias_method :__methods__, :methods
+    alias_method :__is_a?, :is_a?
+    instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval|object_id|proxy_class/ }
+  end
+end
+

data/lib/spontaneous/publishing/fire_and_forget.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'fire_and_forget'
+
+module Spontaneous
+  module Publishing
+    class FireAndForget
+      FAF = ::FireAndForget
+
+      def self.task_name
+        # TODO: add site name to this to make it unique on a server
+        :publish
+      end
+
+      def self.register_task
+        publish_binary = (Pathname.new(Spontaneous.gem_dir) + "bin/spot publish").expand_path.to_s
+        site_root = Pathname.new(Spontaneous.root).expand_path.to_s
+        niceness = S.config.publish_niceness || 15
+        # TODO: make nice value configurable
+        FAF.add_task(task_name, publish_binary, niceness, {
+          "site" => site_root,
+          "logfile" => "log/publish.log",
+          "environment" => Spontaneous.env
+        }, {})
+      end
+
+      register_task
+
+      def self.status
+        FAF.get_status(task_name)
+      end
+
+      def self.status=(status)
+        FAF.set_status(task_name, status)
+      end
+
+      attr_reader :revision
+
+      def initialize(revision)
+        @revision = revision
+      end
+
+      def task_name
+        self.class.task_name
+      end
+
+      def publish_changes(change_list)
+        FAF.fire(task_name, {"changes" => change_list})
+      end
+
+      def publish_all
+        FAF.fire(task_name)
+      end
+    end # FireAndForget
+  end # Publishing
+end # Spontaneous
+

data/lib/spontaneous/publishing/immediate.rb

@@ -0,0 +1,197 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Publishing
+    class Immediate
+
+      def self.status
+        @status ||= ""
+      end
+
+      def self.status=(status)
+        @status = status
+      end
+
+      attr_reader :revision
+
+      def initialize(revision)
+        @revision = revision
+        logger.info {  "Publishing revision #{@revision}"}
+      end
+
+      def publish_changes(change_list)
+        changes = change_list.flatten.map { |c|
+          c.is_a?(S::Change) ? c : S::Change[c]
+        }
+        all_changes = S::Change.all
+        if changes == all_changes
+          # 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
+        end
+
+      end
+
+      def publish_all
+        # maybe someone will make a change while we're publishing the site
+        # (but after we've duplicated the tables)
+        # so save the current list of changes
+        # TODO: make sure this is robust
+        changes = S::Change.all
+        publish(nil)
+        changes.each do |change|
+          change.destroy
+        end
+      end
+
+      # Called from the Format#render method to provide progress reports
+      def page_rendered(page)
+        @pages_rendered += 1
+        set_status("rendering", percent_complete)
+        logger.info { "Rendered page #{page.path}" }
+      end
+
+      protected
+
+      def pages
+        @pages ||= S::Page.order(:depth)
+      end
+
+      def formats
+        # TODO: read the actual config for the available formats
+        [:html]
+      end
+
+      def render_stages
+        # TODO: when search infrastructure is in place modify this to include the indexing steps
+        1
+      end
+
+      def publish(pages)
+        at_exit {
+          abort_publish_at_exit
+        }
+        before_publish
+        begin
+          S::Content.publish(revision, pages) do
+            render_revision
+          end
+          after_publish
+        rescue Exception => e
+          abort_publish(e)
+          raise(e)
+        end
+      end
+
+      def render_revision
+        @pages_rendered = 0
+        S::Content.with_identity_map do
+          S::Render.with_publishing_renderer do
+            set_status("rendering:0")
+            formats.each do |format|
+              S::Render.render_pages(revision, pages, format, self)
+            end
+            # only set this after indexing is complete (if any)
+            set_status("rendering:100")
+          end
+        end
+        set_status("copying_files")
+        copy_static_files
+        generate_rackup_file
+      end
+
+      # Used to calculate the progress percentage
+      def total_pages_to_render
+        @total_pages ||= formats.inject(0) do |total, format|
+          total += pages.find_all { |page| page.formats.include?(format) }.count
+        end
+      end
+
+      def percent_complete
+        ((@pages_rendered || 0).to_f / (total_pages_to_render * render_stages).to_f) * 100.0
+      end
+
+      def set_status(state, progress='*')
+        self.class.status = "#{state}:#{progress}"
+      end
+
+      def generate_rackup_file
+        # use the real path to the app rather than the symlink in order to sandbox the live site
+        # not sure that this is a good idea: it would force a publish for every deploy
+        # which is only sometimes appropriate/desirable
+        path = Pathname.new(Spontaneous.root).realpath.to_s
+        # TODO: enable custom rack middleware by changing config/front into a proper rackup file
+        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
+        rack_file = Spontaneous.revision_dir(revision) / 'config.ru'
+        File.open(rack_file, 'w') { |f| f.write(template) }
+        end
+
+      def copy_static_files
+        public_dest = Pathname.new(Spontaneous.revision_dir(revision) / 'public')
+        public_src = Pathname.new(Spontaneous.root / 'public').realpath
+        FileUtils.mkdir_p(public_dest) unless File.exists?(public_dest)
+        Dir[public_src.to_s / "**/*"].each do |src|
+          src = Pathname.new(src)
+          dest = (public_dest + src.relative_path_from(public_src))
+          if src.directory?
+            dest.mkpath
+          else
+            FileUtils.ln(src, dest, :force => true)
+          end
+        end
+      end
+
+      def before_publish
+        set_status("initialising")
+        S::Site.send(:pending_revision=, revision)
+      end
+
+      def after_publish
+        set_status("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}")
+        set_status("complete")
+      end
+
+      def abort_publish_at_exit
+        abort_publish(nil)
+      end
+
+      def abort_publish(exception)
+        if r = S::Site.pending_revision
+          set_status("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)
+          puts exception.backtrace.join("\n")
+          set_status("error", exception)
+        end
+      end
+    end # Immediate
+  end # Publishing
+end # Spontaneous

data/lib/spontaneous/publishing/threaded.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Publishing
+    class Threaded < Immediate
+
+      alias_method :immediate_publish_changes, :publish_changes
+
+      def publish_changes(change_list)
+        Thread.new do
+          immediate_publish_changes(change_list)
+        end
+      end
+
+      alias_method :immediate_publish_all, :publish_all
+
+      def publish_all
+        Thread.new do
+          immediate_publish_all
+        end
+      end
+    end # Forked
+  end # Publishing
+end # Spontaneous
+

data/lib/spontaneous/publishing.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Publishing
+    autoload :Immediate, "spontaneous/publishing/immediate"
+    autoload :Threaded, "spontaneous/publishing/threaded"
+    autoload :FireAndForget, "spontaneous/publishing/fire_and_forget"
+  end # Publishing
+end # Spontaneous
+

data/lib/spontaneous/rack/around_back.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require 'less'
+
+module Spontaneous
+  module Rack
+    class AroundBack
+      def initialize(app)
+        @app = app
+      end
+
+      def user(env)
+        if login = Site.config.auto_login
+          user = Spontaneous::Permissions::User[:login => login]
+        else
+          request = ::Rack::Request.new(env)
+          api_key = request.cookies[Spontaneous::Rack::Back::AUTH_COOKIE]
+          if api_key && key = Spontaneous::Permissions::AccessKey.authenticate(api_key)
+            key.user
+          else
+            nil
+          end
+        end
+      end
+
+      def call(env)
+        response = nil
+        Content.with_identity_map do
+          Spontaneous::Permissions.with_user(user(env)) do
+            S::Render.with_preview_renderer do
+              Change.record do
+                response = @app.call(env)
+              end
+            end
+          end
+        end
+        response
+      end
+
+    end
+
+  end
+end
+