spontaneous 0.1.0.alpha1

data/lib/spontaneous/plugins/entries.rb

@@ -0,0 +1,193 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Entries
+
+    def self.configure(base)
+      base.__send__(:alias_method,  :<<, :push)
+    end
+
+    module InstanceMethods
+      CONTENT_PATH_SEP = ".".freeze
+
+      # because it's possible to build content out of order
+      # some relations don't necessarily get created straight away
+      def before_save
+        if container
+          self.page = container.page if page.nil?
+          if page?
+            self.depth = parent ? ((parent.depth || 0) + 1) : 0
+          else
+            self.depth = (container.content_depth || 0) + 1
+          end
+        end
+        super
+      end
+
+      def after_save
+        pieces.each do |entry|
+          entry.save if entry.modified?
+        end
+        super
+      end
+
+      def destroy(remove_container_entry=true, container=nil)
+        container ||= self.container
+        if container && remove_container_entry
+          container.destroy_entry!(self)
+        end
+        super()
+      end
+
+      def before_destroy
+        recursive_destroy
+        super
+      end
+
+      def recursive_destroy
+        all_pieces.destroy
+      end
+
+      def destroy_entry!(entry)
+        pieces.remove(entry)
+        # save the container because it won't be obvious to the caller
+        # that content other than the destroyed object will have been
+        # modified
+        self.save
+      end
+
+      def content_depth
+        depth
+      end
+
+      def entry_modified!(modified_entry)
+        self.entry_store = all_pieces.serialize_db
+      end
+
+      def pieces
+        if Spontaneous::Content.visible_only?
+          visible_pieces
+        else
+          all_pieces
+        end
+      end
+
+      # ensure that all access to pieces is through their corresponding entry
+      # alias_method :pieces, :entries
+
+      def all_pieces
+        @all_pieces ||= Spontaneous::Collections::EntrySet.new(self, entry_store)
+      end
+
+      def visible_pieces
+        @visible_pieces ||= all_pieces.visible!
+      end
+
+      protected(:all_pieces, :visible_pieces)
+
+      def reload
+        @all_pieces = @visible_pieces = nil
+        super
+      end
+
+
+      def first
+        pieces.first
+      end
+
+      def last
+        pieces.last
+      end
+
+      def push(page_or_piece)
+        insert(-1, page_or_piece)
+      end
+
+      def insert(index, page_or_piece, box = nil)
+        save if new?
+        if page_or_piece.page?
+          insert_page(index, page_or_piece, box)
+        else
+          insert_piece(index, page_or_piece, box)
+        end
+      end
+
+
+      def insert_page(index, child_page, box = nil)
+        child_page.container = self
+        if page
+          child_page.depth = page.depth + 1
+          page.children << child_page
+          child_page.parent = page
+          child_page.update_path
+        end
+        insert_with_style(:page, index, child_page, box)
+      end
+
+      def insert_piece(index, piece, box = nil)
+        piece.container = self
+        piece.page = page if page
+        piece.depth = (content_depth || 0) + 1
+        insert_with_style(:piece, index, piece, box)
+      end
+
+      def insert_with_style(type, index, content, box = nil)
+        self._pieces << content
+        entry_style = style_for_content(content, box)
+        content.box_sid = box.schema_id if box
+        content._prototype = box.prototype_for_content(content) if box
+        content.save if content.new?
+        entry = \
+          case type
+          when :page
+            Spontaneous::PagePiece.new(self, content, entry_style ? entry_style.schema_id : nil)
+          when :piece
+            content.style = entry_style
+            content
+          end
+        begin
+          pieces.insert(index, entry)
+        rescue TypeError, RuntimeError => e
+          # TODO: raise a custom more helpful error here
+          logger.error { "Attempting to modify visible only pieces" }
+          raise e
+        end
+
+        entry
+      end
+
+      def update_position(position)
+        entry.set_position(position)
+        container.save
+      end
+
+      def set_position(new_position)
+        if box
+          box.set_position(self, new_position)
+        else
+          container.pieces.set_position(self, new_position)
+        end
+      end
+
+      def style_for_content(content, box = nil)
+        if box
+          box.style_for_content(content)
+
+        else
+          content.default_style
+        end
+      end
+
+      def available_styles(content)
+        content.class.styles
+      end
+
+      def container=(container)
+        super
+        self[:content_path] = [container.content_path, container.id].compact.join(CONTENT_PATH_SEP)
+      end
+
+    end # InstanceMethods
+  end # Entries
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/entry.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Entry
+    module InstanceMethods
+
+      # kept to allow access to pages & pieces as they would be seen when
+      # accessed as an entry in a box
+      def entry
+        self
+      end
+
+      def box_sid
+        @box_sid ||= Spot::Schema::UID[self[:box_sid]]
+      end
+
+      def box_sid=(sid)
+        self[:box_sid] = sid.to_s
+      end
+
+      def box
+        container.boxes.sid(box_sid) if container
+      end
+
+      def first?
+        container.pieces.first == self
+      end
+
+      def last?
+        container.pieces.last == self
+      end
+
+      def set_position(new_position)
+        if box
+          box.set_position(self, new_position)
+        else
+          container.pieces.set_position(self, new_position)
+        end
+      end
+
+      def position
+        container.pieces.index(self)
+      end
+
+      def serialize_db
+        [self.id]
+      end
+    end # InstanceMethods
+  end # Entry
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/fields.rb

@@ -0,0 +1,103 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Fields
+    module ClassMethods
+      def field(name, type=nil, options={}, &block)
+        if type.is_a?(Hash)
+          options = type
+          type = nil
+        end
+
+        prototype = Spontaneous::Prototypes::FieldPrototype.new(self, name, type, options, &block)
+        field_prototypes[name] = prototype
+        unless method_defined?(name)
+          define_method(name) do |*args|
+            fields[name].tap { |f| f.template_params = args }
+          end
+        else
+          # raise "Must give warning when field name clashes with method name #{name}"
+        end
+
+        setter = "#{name}=".to_sym
+        unless method_defined?(setter)
+          define_method(setter) { |value| fields[name].value = value  }
+        else
+          # raise "Must give warning when field name clashes with method name"
+        end
+        prototype
+      end
+
+      def field_prototypes
+        @field_prototypes ||= Spontaneous::Collections::PrototypeSet.new(supertype, :field_prototypes)
+      end
+
+      def field_names
+        field_prototypes.order
+      end
+
+      def fields
+        field_prototypes
+      end
+
+      def field_order(*new_order)
+        field_prototypes.order = new_order.flatten if new_order and !new_order.empty?
+      end
+
+      def field?(field_name)
+        field_prototypes.key?(field_name)
+      end
+
+      def field_for_mime_type(mime_type)
+        fields.find do |prototype|
+          prototype.field_class.accepts?(mime_type)
+        end
+      end
+
+      def readable_fields
+        field_prototypes.keys.select { |name| field_readable?(name) }
+      end
+    end
+
+    module InstanceMethods
+      def after_save
+        super
+        fields.saved
+      end
+
+      def reload
+        @field_set = nil
+        super
+      end
+
+      def field_prototypes
+        self.class.field_prototypes
+      end
+
+      def fields
+        @field_set ||= Spontaneous::Collections::FieldSet.new(self, field_store)
+      end
+
+      def field?(field_name)
+        self.class.field?(field_name)
+      end
+
+      # TODO: unify the update mechanism for these two stores
+      def field_modified!(modified_field)
+        self.field_store = @field_set.serialize_db
+      end
+
+      def type_for_mime_type(mime_type)
+        self.class.allowed_types.find do |t|
+          t.field_for_mime_type(mime_type)
+        end
+      end
+
+      def field_for_mime_type(mime_type)
+        prototype = self.class.field_for_mime_type(mime_type)
+        self.fields[prototype.name]
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/instance_code.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module InstanceCode
+
+    module InstanceMethods
+      def after_initialize
+        super
+        mixin_instance_code
+      end
+
+      def mixin_instance_code
+        self.instance_eval(self.instance_code) unless self.instance_code.nil?
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/layouts.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Layouts
+    module ClassMethods
+      def layout(name, options={})
+        layout_prototypes[name] = Spontaneous::Prototypes::LayoutPrototype.new(self, name, options)
+      end
+
+      def layout_prototypes
+        @layout_prototypes ||= Spontaneous::Collections::PrototypeSet.new(supertype, :layout_prototypes)
+      end
+
+      alias_method :layouts, :layout_prototypes
+
+      def resolve_layout(layout_sid)
+        if layout_sid.nil? #layout_name.blank?
+          default_layout
+        else
+          find_layout(layout_sid)
+        end
+      end
+
+      def default_layout
+        if prototype = (layouts.detect { |prototype| prototype.default? } || layouts.first)
+          prototype.layout(self)
+        else
+          Spontaneous::Layout::Default.new(self)
+        end
+      end
+
+      def find_layout(layout_sid)
+        if prototype = layout_prototypes.sid(layout_sid)
+          prototype.layout(self)
+        end
+      end
+
+      def find_named_layout(layout_name)
+        layout_prototypes[layout_name.to_sym]
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      def layout
+        resolve_layout(self.style_sid)
+      end
+
+      def resolve_layout(style_sid)
+        self.class.resolve_layout(style_sid)
+      end
+
+      def layout=(layout)
+        self.style_sid = layout_to_schema_id(layout)
+      end
+
+      def layout_to_schema_id(layout)
+        sid = nil
+        if layout.respond_to?(:schema_id)
+          sid = layout.schema_id
+        else
+          if Spontaneous::Schema::UID === layout
+            sid = layout
+          else
+            if s = self.find_named_layout(layout)
+              sid = s.schema_id
+            end
+          end
+        end
+        sid
+      end
+
+      def find_named_layout(layout_name)
+        self.class.find_named_layout(layout_name)
+      end
+
+      def template(format = :html)
+        layout.template(format)
+      end
+
+      # def provides_format?(format)
+      #   format = (format || :html).to_sym
+      #   self.formats.include?(format)
+      # end
+    end # InstanceMethods
+  end # Layouts
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/media.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Media
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      def media_filepath(*args)
+        File.join(Spontaneous.media_dir, padded_id, padded_revision, *args)
+      end
+
+      def media_urlpath(*args)
+        File.join("/media", padded_id, padded_revision, *args)
+      end
+
+      def padded_id
+        save if media_id.nil?
+        media_id.to_s.rjust(5, "0")
+      end
+
+      def media_id
+        id
+      end
+
+      def padded_revision
+        Spontaneous::Site.working_revision.to_s.rjust(4, "0")
+      end
+
+      def make_media_file(src_file, filename = nil)
+        filename ||= File.basename(src_file)
+        filename = Spontaneous::Media.to_filename(filename)
+        media_filepath = media_filepath(filename)
+        FileUtils.mkdir_p(File.dirname(media_filepath))
+        FileUtils.cp(src_file, media_filepath)
+        media_filepath
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/page/formats.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins::Page
+  module Formats
+    module ClassMethods
+      def formats(*formats)
+        @formats ||= [:html]
+        return @formats if formats.nil? or formats.empty?
+        set_formats(formats)
+      end
+
+      def set_formats(formats)
+        @mime_types = {}
+        formats = formats.flatten
+        mime_type = nil
+        @formats = formats.map do |format|
+          if format.is_a?(Hash)
+            mime_type = format.values.first
+            format = format.keys.first
+            @mime_types[format.to_sym] = mime_type
+          else
+            mime_type = ::Rack::Mime.mime_type("#{Spontaneous::DOT}#{format}", nil)
+          end
+          raise Spontaneous::UnknownFormatException.new(format) unless mime_type
+          format.to_sym
+        end
+      end
+
+      def default_format
+        formats.first
+      end
+
+      def provides_format?(format)
+        format = (format || :html).to_sym
+        formats.include?(format)
+      end
+
+      def mime_type(format)
+        if @mime_types && @mime_types.key?(format)
+          @mime_types[format]
+        else
+          ::Rack::Mime.mime_type("#{Spontaneous::DOT}#{format}")
+        end
+      end
+    end
+
+    module InstanceMethods
+      def formats
+        self.class.formats
+      end
+
+      def default_format
+        self.class.default_format
+      end
+
+      def provides_format?(format)
+        self.class.provides_format?(format)
+      end
+
+      def mime_type(format)
+        self.class.mime_type(format)
+      end
+    end
+  end # Formats
+end # Spontaneous::Plugins::Page
+

data/lib/spontaneous/plugins/page/request.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Page
+  module Request
+    # liked this but it didn't work particularly well so wasn't used in the end
+    # perhaps, when I re-write the bloody Public handler i can use it
+    class PageResponse
+      attr_reader :page, :format, :request, :response
+
+      def initialize(page, request, response, format)
+        @page, @request, @response, @format = page, request, response, format
+      end
+
+      def headers(hash=nil)
+        response.headers.merge! hash if hash
+        response.headers
+      end
+
+      def session; request.session; end
+      def params;  request.params; end
+
+
+
+      def call(&block)
+        response = catch(:halt) { instance_eval(&block) }
+        case response
+        when String
+          [200, Spontaneous::Site[response]]
+        when (100..599) === response
+          [response, page]
+        else
+          response
+        end
+      end
+
+      REDIRECTS = {
+        :permanent => 301,
+        :temporary => 302
+      }
+
+      def redirect(redirection, redirect_code=:temporary)
+        redirection = Spontaneous::Site[redirection] if String === redirection
+        redirect_code = REDIRECTS[redirect_code] if Symbol === redirect_code
+        redirect_code ||= REDIRECTS[:temporary]
+        throw(:halt, [redirect_code, redirection])
+      end
+
+      def show(page, status_code = 200)
+        page = Spontaneous::Site[page] if String === page
+        throw(:halt, [status_code, page])
+      end
+    end
+
+
+    module ClassMethods
+      def request(method = :get, &block)
+        request_blocks[method.to_sym] = block
+      end
+
+      def request_blocks
+        @request_blocks ||= {}
+      end
+
+      # unused at present
+      def _request_response(instance, request, response, format)
+        method = request.request_method.downcase.to_sym
+        if (block = request_blocks[method])
+          app = PageResponse.new(instance, request, response, format)
+          app.call(&block)
+        else
+          nil
+        end
+      end
+    end # ClassMethods
+
+
+    module InstanceMethods
+      def request_block(request)
+        method = request.request_method.downcase.to_sym
+        self.class.request_blocks[method]
+      end
+
+      def is_dynamic?
+        self.class.request_blocks.key?(:get)
+      end
+    end
+  end # Request
+end
+

data/lib/spontaneous/plugins/page_search.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module PageSearch
+    module ClassMethods
+      def root
+        first_visible(:path => Spontaneous::SLASH)
+      end
+
+      def uid(uid)
+        first_visible(:uid => uid)
+      end
+
+      def path(path)
+        page = first_visible(:path => path)
+        page = aliased_path(path) if page.nil?
+        page
+      end
+
+      def first_visible(params)
+        page = Spontaneous::Content.first(params)
+        # don't want to return nil if a page matching the params exists but is hidden
+        # if we return blank we force searches via other routes (such as aliased pages)
+        if page and Spontaneous::Content.visible_only? and page.hidden?
+          return false
+        end
+        page
+      end
+
+      def aliased_path(path)
+        @_ps ||= Hash.new { |h, k| h[k] = prepare_aliased_path_query(k) }
+        p = path.split(S::SLASH)
+        root = p[0..-2].join(S::SLASH)
+        visible = Spontaneous::Content.visible_only?
+        @_ps[visible].call(:root => root, :slug => p.last)
+      end
+
+      protected
+
+      def prepare_aliased_path_query(visible_only=false)
+        # select c2.*
+        # from content as c1, content as c2, content as c3 \
+        # where c1.path = '/aliases'
+        #   and c2.parent_id = c1.id
+        #   and c2.target_id = c3.id
+        #   and c3.slug = 'b';
+        params = {
+          :c1__path => :$root,
+          :c2__parent_id => :c1__id,
+          :c2__target_id => :c3__id,
+          :c3__slug => :$slug
+        }
+        params.merge!(:c3__hidden => false) if visible_only
+
+        query = S::Content._unfiltered_dataset.select(Sequel::LiteralString.new("c2.*")).from(:content___c1, :content___c2, :content___c3).where(params)
+        query.prepare(:first)
+      end
+    end
+
+    # module InstanceMethods
+    # end
+  end
+end
+