spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/prototypes/box_prototype.rb

@@ -1,17 +1,26 @@
 # encoding: UTF-8
 
-require 'hwia'
 
 module Spontaneous::Prototypes
   class BoxPrototype
 
     attr_reader :name, :options, :owner
 
-    def initialize(owner, name, options, &block)
+    def initialize(owner, name, options, blocks = [], &block)
       @owner = owner
       @name = name.to_sym
       @options = options
-      @extend = block
+      @extend = [blocks].flatten.push(block).compact
+      instance_class
+      self
+    end
+
+    def position
+      owner.box_position(self)
+    end
+
+    def __source_file
+      owner.__source_file
     end
 
     def field_prototypes
@@ -23,10 +32,9 @@ module Spontaneous::Prototypes
     end
 
     def schema_id
-      instance_class.schema_id
+      Spontaneous.schema.uids[@_inherited_schema_id] || instance_class.schema_id
     end
 
-
     def schema_name
       instance_class.schema_name
     end
@@ -47,12 +55,33 @@ module Spontaneous::Prototypes
       @options[:fields]
     end
 
+    def group
+      @options[:group]
+    end
+
     def instance_class
       @_instance_class ||= create_instance_class
     end
 
+    def inherit_schema_id(schema_id)
+      @_inherited_schema_id = instance_class.schema_id = schema_id.to_s
+    end
+
+    def merge(subclass_owner, subclass_options, &subclass_block)
+      options = @options.merge(subclass_options)
+      Spontaneous::Prototypes::BoxPrototype.new(subclass_owner, name, options, @extend, &subclass_block).tap do |prototype|
+        # We want merged boxes, which are essentially monkey-patched box definitions
+        # to use the same schema id as the supertype version because otherwise removing the
+        # subtype version and falling back to the original supertype definition would remove
+        # all the content from the box while the box itself would still remain visible in the UI
+        prototype.inherit_schema_id self.schema_id
+      end
+    end
+
     def create_instance_class
       Class.new(box_base_class).tap do |instance_class|
+        # doing this means we get proper names for the anonymous box classes
+        owner.const_set("#{name.to_s.camelize}Box", instance_class)
         box_owner = owner
         box_name = name
         instance_class.instance_eval do
@@ -66,17 +95,14 @@ module Spontaneous::Prototypes
             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)
+        @extend.each { |block|
+          instance_class.class_eval(&block) if block
+        }
       end
     end
 
     def box_base_class
-      box_class = Spontaneous::Box # AnonymousBox
+      box_class = default_box_class
       class_name = @options[:type] || @options[:class]
       box_class = class_name.to_s.constantize if class_name
       # box_class = Class.new(box_class) do
@@ -87,6 +113,10 @@ module Spontaneous::Prototypes
       box_class
     end
 
+    def default_box_class
+      defined?(::Box) ? ::Box : Spontaneous::Box
+    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
@@ -125,26 +155,26 @@ module Spontaneous::Prototypes
     end
 
     # TODO: must be able to make these into a module
-    def readable?
-      Spontaneous::Permissions.has_level?(read_level)
+    def readable?(user)
+      Spontaneous::Permissions.has_level?(user, read_level)
     end
 
-    def writable?
-      Spontaneous::Permissions.has_level?(write_level)
+    def writable?(user)
+      Spontaneous::Permissions.has_level?(user, write_level)
     end
 
     def style
       @options[:style]# || name
     end
 
-    def readable_fields
-      instance_class.readable_fields
+    def readable_fields(user)
+      instance_class.readable_fields(user)
     end
 
-    def allowed_types
-      if writable?
+    def allowed_types(user)
+      if writable?(user)
         types = []
-        instance_class.allowed.select { |a| a.readable? }.each do  |a|
+        instance_class.allowed.select { |a| a.readable?(user) }.each do  |a|
           types.concat(a.instance_classes)
         end
         types
@@ -153,15 +183,15 @@ module Spontaneous::Prototypes
       end
     end
 
-    def export
-      allowed = allowed_types.map { |c| c.ui_class }
+    def export(user)
+      allowed = allowed_types(user).map { |c| c.ui_class }
       {
         :name => name.to_s,
         :id => schema_id.to_s,
         :title => title,
-        :writable => writable?,
+        :writable => writable?(user),
         :allowed_types => allowed,
-        :fields => readable_fields.map { |name| instance_class.field_prototypes[name].export },
+        :fields => readable_fields(user).map { |name| instance_class.field_prototypes[name].export(user) },
       }
     end
   end

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -3,33 +3,33 @@
 
 module Spontaneous::Prototypes
   class FieldPrototype
-    attr_reader :owner, :name
+    attr_reader :owner, :name, :options
 
-    def initialize(owner, name, type, options={})
+    def initialize(owner, name, type, options={}, blocks = [], &block)
       @owner = owner
       @name = name
+      @extend = [blocks].flatten.push(block).compact
+
+      parse_options(options)
+
       # 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
+      @base_class = Spontaneous::FieldTypes[type || name]
 
-      # @field_class.prototype = self
-      parse_options(options)
+      owner.const_set("#{name.to_s.camelize}Field", instance_class)
+
+      self
     end
 
     def schema_name
       "field/#{owner.schema_id}/#{name}"
     end
 
+    # def schema_id
+    #   Spontaneous.schema.schema_id(self)
+    # end
     def schema_id
-      Spontaneous::Schema.schema_id(self)
+      Spontaneous.schema.uids[@_inherited_schema_id] || Spontaneous.schema.schema_id(self)
     end
 
     def schema_owner
@@ -62,8 +62,27 @@ module Spontaneous::Prototypes
       }.merge(options)
     end
 
+    def instance_class
+      @_instance_class ||= create_instance_class
+    end
+
+    def create_instance_class
+      base_class = @base_class
+      Class.new(@base_class).tap do |instance_class|
+        # although we're subclassing the base field class, we don't want the ui
+        # to use a different editor. FieldClass::editor_class is used in the serialisation
+        # routine
+        # instance_class.singleton_class.send(:define_method, :editor_class) do
+        #   base_class.editor_class
+        # end
+        @extend.each { |block|
+          instance_class.class_eval(&block) if block
+        }
+      end
+    end
+
     def field_class
-      @field_class
+      instance_class
     end
 
     def default
@@ -87,25 +106,53 @@ module Spontaneous::Prototypes
       Spontaneous::Permissions[level_name]
     end
 
+    def in_index?(index)
+      search.in_index?(index)
+    end
+
+    def index_id(index)
+      search.index_id(index)
+    end
+
+    def options_for_index(index)
+      search.field_definition(index)
+    end
+
+    def search
+      @search ||= S::Search::Field.new(self, @options[:index])
+    end
+
+    def inherit_schema_id(schema_id)
+      @_inherited_schema_id = schema_id.to_s
+      # instance_class.schema_id = schema_id
+    end
+
+    def merge(subclass_owner, field_type, subclass_options, &subclass_block)
+      options = @options.merge(subclass_options)
+      self.class.new(subclass_owner, name, field_type, options, @extend, &subclass_block).tap do |prototype|
+        prototype.inherit_schema_id self.schema_id
+      end
+    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|
+      self.instance_class.new(values, !default_values).tap do |field|
         field.prototype = self
       end
     end
 
-    def export
+    def export(user)
       {
         :name => name.to_s,
         :schema_id => schema_id.to_s,
-        :type => field_class.ui_class,
+        :type => instance_class.editor_class,
         :title => title,
         :comment => comment || "",
-        :writable => Spontaneous::Permissions.has_level?(write_level)
+        :writable => Spontaneous::Permissions.has_level?(user, write_level)
       }
     end
   end

data/lib/spontaneous/prototypes/style_prototype.rb

@@ -29,10 +29,10 @@ module Spontaneous::Prototypes
     end
 
     def schema_id
-      Spontaneous::Schema.schema_id(self)
+      Spontaneous.schema.schema_id(self)
     end
 
-    def export
+    def export(user)
       {
         :name => name.to_s,
         :schema_id => schema_id.to_s

data/lib/spontaneous/publishing.rb

@@ -4,7 +4,7 @@ module Spontaneous
   module Publishing
     autoload :Immediate, "spontaneous/publishing/immediate"
     autoload :Threaded, "spontaneous/publishing/threaded"
-    autoload :FireAndForget, "spontaneous/publishing/fire_and_forget"
+    autoload :Simultaneous, "spontaneous/publishing/simultaneous"
   end # Publishing
 end # Spontaneous
 

data/lib/spontaneous/publishing/immediate.rb

@@ -1,16 +1,21 @@
 # encoding: UTF-8
 
+require 'simultaneous'
+require 'sass'
+
 module Spontaneous
   module Publishing
     class Immediate
 
-      def self.status
-        @status ||= ""
-      end
+      # def self.status
+      #   @status ||= ""
+      # end
 
-      def self.status=(status)
-        @status = status
-      end
+      # def self.status=(status)
+      #   @status = status
+      # end
+
+      include ::Simultaneous::Task
 
       attr_reader :revision
 
@@ -50,36 +55,33 @@ module Spontaneous
         end
       end
 
-      # Called from the Format#render method to provide progress reports
-      def page_rendered(page)
+      protected
+
+      def page_rendered(page, event = "rendering")
         @pages_rendered += 1
-        set_status("rendering", percent_complete)
-        logger.info { "Rendered page #{page.path}" }
+        update_progress(event, percent_complete)
+        logger.info { "Done: #{event} page #{page.path} #{percent_complete.round(1)}%" }
       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
+      # 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
       end
 
-      def publish(pages)
+      def publish(modified_page_list)
         at_exit {
           abort_publish_at_exit
         }
         before_publish
         begin
-          S::Content.publish(revision, pages) do
+          S::Content.publish(revision, modified_page_list) do
             render_revision
           end
           after_publish
@@ -90,44 +92,75 @@ module Spontaneous
       end
 
       def render_revision
+        update_progress("rendering", 0)
         @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)
+          S::Content.with_visible do
+            S::Render.with_publishing_renderer do
+              render_pages
+              index_pages unless index_stages == 0
             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
 
+      def render_pages
+        # 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)
+          end
+          sleep(delay) if delay
+        end
+      end
+
+      def render_page(page, format)
+        logger.info { "#{page.path}" }
+        formatter = Spontaneous::Render::Format.for(format)
+        renderer = formatter.new(revision, page)
+        renderer.render
+        page_rendered(page)
+      end
+
+      def index_pages
+        S::Site.indexer(revision) do |indexer|
+          pages.each { |page|
+            indexer << page
+            page_rendered(page, 'indexing')
+          }
+        end
+      end
+
       # Used to calculate the progress percentage
+      # 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 ||= formats.inject(0) do |total, format|
-          total += pages.find_all { |page| page.formats.include?(format) }.count
+        @total_pages ||= (index_stages * pages.count) + pages.inject(0) do |total, page|
+          total += page.formats.length#count { |page| page.formats.include?(format) }
         end
       end
 
       def percent_complete
-        ((@pages_rendered || 0).to_f / (total_pages_to_render * render_stages).to_f) * 100.0
+        ((@pages_rendered || 0).to_f / (total_pages_to_render).to_f) * 100.0
       end
 
-      def set_status(state, progress='*')
-        self.class.status = "#{state}:#{progress}"
+      def update_progress(state, progress='*')
+        simultaneous_event('publish_progress', {:state => state, :progress => progress}.to_json)
       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
+        # UPDATE: What was I on about there? The true downside to this is that it would force a restart/HUP for
+        # every publish. Not sure that the comment above this one is based on truth or some mad momentary fantasy
         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
@@ -141,41 +174,87 @@ module Spontaneous
           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
+      end
 
       def copy_static_files
+        update_progress("copying_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)
+        facets = Spontaneous.instance.facets
+        public_dirs = facets.map { |facet| facet.paths.expanded(:public) }.flatten
+        facets.each do |facet|
+          copy_facet_public_files(facet, public_dest)
+        end
+      end
+
+      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
+                  FileUtils.ln(src, dest, :force => true)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def render_sass_template(template, dest)
+        dest_css = [dest.basename('.scss'), "css"].join(".")
+        dest = (dest.dirname + dest_css)
+
+        dir = File.dirname(template)
+        load_paths = [dir, File.join(dir, "sass")]
+
+        File.open(dest, 'w') do |file|
+          begin
+            engine = Sass::Engine.for_file(template.to_s, {
+              :filename => template.to_s,
+              :load_paths => load_paths,
+              :cache => false,
+              :style => :compressed
+            })
+            file.write(engine.render)
+          rescue Sass::SyntaxError => e
+            # it's likely that the error is coming from rendering an include file that isn't designed to
+            # be rendered singly (i.e. it depends on another include file)
+            # but let's show an error anyway
+            logger.warn(e)
           end
         end
       end
 
       def before_publish
-        set_status("initialising")
+        update_progress("initialising")
         S::Site.send(:pending_revision=, revision)
       end
 
       def after_publish
-        set_status("finalising")
+        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}")
-        set_status("complete")
+        update_progress("complete")
       end
 
       def abort_publish_at_exit
@@ -184,12 +263,12 @@ module Spontaneous
 
       def abort_publish(exception)
         if r = S::Site.pending_revision
-          set_status("aborting")
+          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)
           puts exception.backtrace.join("\n")
-          set_status("error", exception)
+          update_progress("error", exception)
         end
       end
     end # Immediate