spontaneous 0.1.0.alpha1

data/lib/spontaneous/render/published_renderer.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Render
+    class PublishedRenderer < Renderer
+      NGINX_DETECT_HEADER = "X-Nginx"
+      NGINX_ACCEL_REDIRECT = "X-Accel-Redirect"
+
+      def render_content(content, format=:html, params = {})
+        request = params[:request]
+        response = params[:response]
+        headers = request.env
+        render = nil
+        if Spontaneous.development? and Spontaneous.config.rerender_pages
+          # in dev mode we just want to render the page dynamically, skipping the cached version
+          render = rerender(content, format, params)
+        else
+          # first test for dynamic template
+          template = Spontaneous::Render.output_path(Content.revision, content, format, extension)
+
+          if File.exists?(template)
+            render = request_renderer.render_file(template, content, format, params)
+          else
+
+            # if no dynamic template exists then try for a static file
+            # this case will normally be handled by the proxy server (nginx, apache...)
+            # in production environments
+            template = Spontaneous::Render.output_path(Content.revision, content, format)
+
+            if File.exists?(template)
+              # first check to see if we're behind an nginx proxy
+              if headers.key?(NGINX_DETECT_HEADER)
+                # if so, then use nginx's sendfile mechanism to return the file
+                response.headers[NGINX_ACCEL_REDIRECT] = Spontaneous::Render.redirect_path(Content.revision, content, format)
+              else
+                # if not, then return the file ourselves
+                render = File.read(template)
+              end
+            else
+              # and if all else fails, just re-render the damn thing
+              render = rerender(content, format, params)
+            end
+          end
+        end
+        render
+      end
+
+      def rerender(content, format = :html, params = {})
+        template = publishing_renderer.render_file(content.template(format), content, format)
+        request_renderer.render_string(template, content, format, params)
+      end
+    end # PublishedRenderer
+  end # Render
+end # Spontaneous

data/lib/spontaneous/render/publishing_renderer.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Render
+    class PublishingRenderer < Renderer
+      def render_content(content, format=:html, params = {})
+        publishing_renderer.render_file(content.template(format), content, format, params)
+      end
+    end # PublishingRenderer
+  end  # Render
+end  # Spontaneous
+

data/lib/spontaneous/render/renderer.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Render
+    class Renderer
+
+      attr_reader :template_root
+
+      def initialize(template_root)
+        @template_root = template_root
+      end
+
+      def render_content(content, format=:html, params = {})
+        # overwrite in subclasses
+      end
+
+      def template_file(filename, format)
+        Render.template_file(template_root, filename, format)
+      end
+
+      def extension
+        Spontaneous.template_engine.extension
+      end
+
+      protected
+
+      def preview_renderer
+        Spontaneous.template_engine.preview_renderer.new(template_root, cache?)
+      end
+
+      def publishing_renderer
+        Spontaneous.template_engine.publishing_renderer.new(template_root, cache?)
+      end
+
+      def request_renderer
+        Spontaneous.template_engine.request_renderer.new(template_root, cache?)
+      end
+
+      def cache?
+        Spontaneous::Render.cache_templates?
+      end
+    end # Renderer
+  end  # Render
+end  # Spontaneous
+

data/lib/spontaneous/render.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Render
+
+    class << self
+      def output_path(revision, page, format, extension = nil)
+        output_path_with_root(revision_root(revision), revision, page, format, extension)
+      end
+
+      def output_path_with_root(root, revision, page, format, extension = nil)
+        ext = ".#{format}"
+        ext += ".#{extension}" if extension
+
+        dir = root / format / page.path
+        path = dir / "/index#{ext}"
+        path
+      end
+
+      def redirect_path(revision, page, format)
+        output_path_with_root(Spontaneous.revision_dir(revision, "/"), revision, page, format)
+      end
+
+
+      def revision_root(revision)
+        Spontaneous.revision_dir(revision)
+      end
+
+      def cache_templates?
+        @cache_templates ||= Spontaneous.production?
+      end
+
+      def cache_templates=(value)
+        @cache_templates = value
+      end
+
+      def render_pages(revision, pages, format, progress=nil)
+        klass = Format.const_get("#{format.to_s.camelize}")
+        renderer = klass.new(revision, pages, progress)
+        renderer.render
+      end
+
+      def render_page(revision, page, format, progress=nil)
+        render_pages(revision, [page], format, progress)
+      end
+
+      def renderer_class
+        @renderer_class ||= PublishingRenderer
+      end
+
+      def renderer_class=(klass)
+        @renderer_class = klass
+        @renderer = nil
+      end
+
+      def renderer
+        @renderer ||= renderer_class.new(template_root)
+      end
+
+      def with_preview_renderer(&block)
+        with_renderer(PreviewRenderer, &block)
+      end
+
+      def with_publishing_renderer(&block)
+        with_renderer(PublishingRenderer, &block)
+      end
+
+      def with_published_renderer(&block)
+        with_renderer(PublishedRenderer, &block)
+      end
+
+      def use_development_renderer
+        self.renderer_class = DevelopmentRenderer
+      end
+
+      def use_preview_renderer
+        self.renderer_class = PreviewRenderer
+      end
+
+      def use_publishing_renderer
+        self.renderer_class = PublishingRenderer
+      end
+
+      def use_published_renderer
+        self.renderer_class = PublishedRenderer
+      end
+
+      @@renderer_stack = []
+
+      def with_renderer(new_renderer, &block)
+        @@renderer_stack.push(self.renderer_class)
+        self.renderer_class = new_renderer
+        yield if block_given?
+      ensure
+        self.renderer_class = @@renderer_stack.pop
+      end
+
+
+      def template_root
+        @template_root ||= Spontaneous.root / "templates"
+      end
+
+      def template_path(*path)
+        ::File.join(template_root, *path)
+      end
+
+      def template_root=(root)
+        @template_root = root
+        @renderer = nil
+      end
+
+      def extension
+        Spontaneous.template_ext
+      end
+
+      def exists?(root, template, format)
+        File.exists?(template_file(root, template, format))
+      end
+
+      def template_file(root, filename, format)
+        ::File.join(root, template_name(filename, format))
+      end
+
+      def template_file_with_root(template_root, filename, format)
+        ::File.join(template_root, template_name(filename, format))
+      end
+
+      # converts relative paths into absolute template paths
+      # e.g. layouts/standard -> /example_com/templates/layouts/standard.html.cut
+      # searches through all available template roots
+      def find_template(filename, format)
+        template_name = template_name(filename, format)
+        return template_name if File.file?(template_name)
+        Spontaneous.template_paths.each do |root|
+          path = root / template_name
+          return path if File.file?(path)
+        end
+        nil
+      end
+
+      def template_name(filename, format)
+        "#{filename}.#{format}.#{Spontaneous.template_ext}"
+      end
+
+
+
+      def formats(style)
+        glob = "#{template_path(style.path)}.*.#{extension}"
+        Dir[glob].map do |file|
+          file.split('.')[-2].to_sym
+        end
+      end
+
+      def render(content, format=:html, params={})
+        Content.with_visible do
+          renderer.render_content(content, format || :html, params)
+        end
+      end
+    end
+    autoload :Engine, "spontaneous/render/engine"
+
+    autoload :Context, "spontaneous/render/context"
+
+    autoload :Renderer, "spontaneous/render/renderer"
+    autoload :PreviewRenderer, "spontaneous/render/preview_renderer"
+    autoload :PublishingRenderer, "spontaneous/render/publishing_renderer"
+    autoload :PublishedRenderer, "spontaneous/render/published_renderer"
+    autoload :DevelopmentRenderer, "spontaneous/render/development_renderer"
+
+    autoload :Format, "spontaneous/render/format"
+  end
+end

data/lib/spontaneous/revision.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class Revision < Sequel::Model(:revisions)
+
+  end
+end

data/lib/spontaneous/schema/schema_modification.rb

@@ -0,0 +1,260 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Schema
+    class SchemaModification
+
+
+      def initialize(missing_from_map, missing_from_schema, grouped=false)
+        @missing_from_map = missing_from_map
+        @missing_from_schema = missing_from_schema
+        @grouped = grouped
+      end
+
+      def select_missing(select_type)
+        @missing_from_schema.select do |reference|
+          reference.category == select_type
+        end
+      end
+
+      def added_classes
+        @missing_from_map[:type].uniq
+      end
+
+      def removed_classes
+        select_missing(:type)
+      end
+
+      def added_fields
+        @missing_from_map[:field].uniq
+      end
+
+      def removed_fields
+        select_missing(:field)
+      end
+
+      def added_boxes
+        @missing_from_map[:box].uniq
+      end
+
+      def removed_boxes
+        select_missing(:box)
+      end
+
+      def added_styles
+        @missing_from_map[:style].uniq
+      end
+
+      def removed_styles
+        select_missing(:style)
+      end
+
+      def added_layouts
+        @missing_from_map[:layout].uniq
+      end
+
+      def removed_layouts
+        select_missing(:layout)
+      end
+
+      def resolvable?
+        if @grouped
+          simple_change?
+        else
+          all_independent_changes?
+        end
+      end
+
+      def simple_change?
+        only_removed_items? or only_added_items?
+      end
+
+      def only_added_items?
+        if removed_items.empty?
+          !added_items.empty?
+        else
+          false
+        end
+      end
+
+      def only_removed_items?
+        if removed_items.empty?
+          false
+        else
+          added_items.empty?
+        end
+      end
+
+      def all_independent_changes?
+        !changes_grouped_by_owner.find { |change| !change.resolvable? }
+      end
+
+      def changes_grouped_by_owner
+        @changes_grouped ||= create_changes_grouped_by_owner
+      end
+
+      def create_changes_grouped_by_owner
+        # gulp
+        added = Hash.new { |hash, key|
+          hash[key] = Hash.new { | hash, key | hash[key] = [] }
+        }
+        removed = Hash.new { |hash, key| hash[key] = [] }
+
+        # group changed items by category + UIDs because in the case of removals
+        # the owner might have gone (e.g. in the case of a box with
+        # a field that has been removed, the field would show as removed
+        # and reference the box as owner but that box is no longer present)
+        removed_items.each do |removal|
+          removed[change_group_key(removal.category, removal.owner_sid)] << removal
+        end
+
+        @missing_from_map.each do |category, additions|
+          additions.each do |addition|
+            added[change_group_key(category, addition.owner_sid)][category] << addition
+          end
+        end
+
+        owners = added.keys | removed.keys
+        grouped = []
+
+        owners.each do |owner|
+          grouped << SchemaModification.new(added[owner], removed[owner], true)
+        end
+        grouped
+      end
+
+      def change_group_key(category, uid)
+        [category, uid]
+      end
+
+      def resolve!
+        if @grouped
+          resolve_simple
+        else
+          changes_grouped_by_owner.each { |change| change.resolve! }
+        end
+      end
+
+      def resolve_simple
+        if only_added_items?
+          added_items.each do |obj|
+            logger.warn("Adding #{obj} to Schema")
+            Spontaneous::Schema.generate_schema_for(obj)
+          end
+        end
+
+        if only_removed_items?
+          removed_items.each do |uid|
+            uid.destroy
+          end
+        end
+      end
+
+      def added_items
+        @missing_from_map.map { |cat, obj| obj }.flatten
+      end
+
+      def removed_items
+        @missing_from_schema
+      end
+
+      def owners
+        if @grouped
+          added   = added_items.map   { | obj | obj.schema_owner }
+          removed = removed_items.map { | uid | uid.schema_owner }
+          owners = (added | removed).uniq
+          raise "Invalid grouping of schema modifications" unless owners.length == 1
+          [owners.first]
+        else
+          changes_grouped_by_owner.map { |change| change.owners }
+        end
+      end
+
+      def error_messages
+        if @grouped
+          if !simple_change?
+            "Unable to resolve changes to #{owners.join(", ")}"
+          else
+            nil
+          end
+        else
+          changes_grouped_by_owner.map { |change| change.error_messages }.compact
+        end
+      end
+
+      class Solution < Array
+        attr_reader :source
+        def initialize(source, destinations)
+          super()
+          @source, @destinations = source, destinations
+          self << Action.new(:delete, source)
+          @destinations.each do |dest|
+            self << Action.new(:rename, source, dest)
+          end
+        end
+
+        def description
+          "Unable to resolve #{source.category} '#{source.name}' of #{source.owner}"
+        end
+
+      end
+
+
+      class Action
+        attr_reader :action, :source, :dest
+
+        def initialize(action, source, dest = nil)
+          @action, @source, @dest = action, source, dest
+        end
+
+        def description
+          case action
+          when :delete
+            "Delete #{category} '#{source.name}'"
+          when :rename
+            "Rename #{category} '#{source.name}' to '#{dest.name}'"
+          end
+        end
+
+
+        def category
+          @source.category
+        end
+
+        def export
+          hash = [@action.to_s, category, source.name]
+          hash << dest.name if dest
+          hash
+        end
+
+        def path
+          path = ["#{action}?uid=#{source.to_s}"]
+          path << "ref=#{::Rack::Utils.escape(dest.schema_name)}" if action == :rename
+          path.join("&amp;")
+        end
+      end
+
+      def actions
+        if @grouped
+          if simple_change?
+            nil
+          else
+            Solution.new(removed_items.first, added_items)
+          end
+        else
+          change = changes_grouped_by_owner.find { |c| !c.simple_change? }
+          change.actions
+        end
+      end
+
+      def export
+        actions.map { |action| action.export }
+      end
+
+      def serialise_http
+        Spontaneous.serialise_http(export)
+      end
+    end
+  end
+end