spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

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

@@ -2,6 +2,8 @@
 
 module Spontaneous::Plugins::Page
   module Request
+    extend ActiveSupport::Concern
+
     # 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
@@ -61,6 +63,13 @@ module Spontaneous::Plugins::Page
         @request_blocks ||= {}
       end
 
+      # Tests for existance of a request handler for a method
+      # Used by the publishing mechanism to determine which template bucket a
+      # published page should be placed in.
+      def dynamic?(method = :get)
+        request_blocks.has_key?(method) && !request_blocks[method].nil?
+      end
+
       # unused at present
       def _request_response(instance, request, response, format)
         method = request.request_method.downcase.to_sym
@@ -74,16 +83,13 @@ module Spontaneous::Plugins::Page
     end # ClassMethods
 
 
-    module InstanceMethods
-      def request_block(request)
-        method = request.request_method.downcase.to_sym
-        self.class.request_blocks[method]
-      end
+    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
+    def dynamic?(method = :get)
+      self.class.dynamic?(method)
     end
   end # Request
 end
-

data/lib/spontaneous/plugins/page_search.rb

@@ -2,6 +2,8 @@
 
 module Spontaneous::Plugins
   module PageSearch
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def root
         first_visible(:path => Spontaneous::SLASH)
@@ -13,7 +15,7 @@ module Spontaneous::Plugins
 
       def path(path)
         page = first_visible(:path => path)
-        page = aliased_path(path) if page.nil?
+        # page = aliased_path(path) if page.nil?
         page
       end
 
@@ -27,38 +29,35 @@ module Spontaneous::Plugins
         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
+      # def aliased_path(path)
+      #   puts "looking for 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
+      # 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, :aliased_page)
+      # end
+    end # ClassMethods
   end
 end
-

data/lib/spontaneous/plugins/page_tree.rb

@@ -2,24 +2,71 @@
 
 module Spontaneous::Plugins
   module PageTree
+    extend ActiveSupport::Concern
 
-    module InstanceMethods
-      def ancestors
-        ancestor_path.map { |id| Spontaneous::Content[id] }
-      end
+    # InstanceMethods
 
-      def ancestor(depth)
-        ancestors[depth]
-      end
+    def ancestors
+      @ancestors ||= ancestor_path.map { |id| Spontaneous::Content[id] }
+    end
+
+    def ancestor(depth)
+      ancestors[depth]
+    end
 
-      def generation
-        parent ? parent.children : [root]
+    # Returns a list of all the pages at a certain depth in the page tree for any page
+    def at_depth(depth)
+      return root_at_depth(depth) if is_root?
+      parent_depth = [0, depth - 1].max
+      parent = ancestor(parent_depth)
+      unordered_pages = parent.children
+      # This is made more complex because the #children method is unordered
+      # whereas the actual page order must come from the boxes
+      return unordered_pages if parent.boxes.empty?
+      ordered_pages = []
+      # Iterate through the list of boxes and pull out of the
+      # unordered page list each page that belongs to the current box
+      parent.boxes.each do |box|
+        box_id = box.schema_id.to_s
+        in_box, unordered_pages = unordered_pages.partition { |p| p.box_sid == box_id }
+        ordered_pages.concat in_box.sort { |a, b| a.position <=> b.position }
       end
+      ordered_pages
+    end
 
-      def siblings
-        generation.reject { |p| p === self }
+    def root_at_depth(depth)
+      case depth
+      when 0
+        self
+      when 1
+        self.children
+      else
+        raise ArgumentError.new("Cannot calculate descendents of root beyond a depth of 1")
       end
     end
+
+    def ancestor?(page)
+      ancestor_path.include?(page.id)
+    end
+
+    def active?(page)
+      page.id == self.id or ancestor?(page)
+    end
+
+    def generation
+      parent ? parent.children : [root]
+    end
+
+    def siblings
+      generation.reject { |p| p === self }
+    end
+
+    def >(page)
+      page.ancestors.include?(self)
+    end
+
+    def >=(page)
+      page == self or self.>(page)
+    end
   end
 end
-

data/lib/spontaneous/plugins/paths.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins
   module Paths
+    extend ActiveSupport::Concern
 
     module ClassMethods
       def generate_default_slug
@@ -14,111 +14,116 @@ module Spontaneous::Plugins
       end
     end
 
-    module InstanceMethods
-      ANCESTOR_SEP = "."
+    # InstanceMethods
 
-      def after_initialize
-        super
-        self.slug = default_slug if slug.nil?
-      end
+    ANCESTOR_SEP = "."
 
-      def before_create
-        place_in_page_tree
-        super
-      end
+    def after_initialize
+      super
+      self.slug = default_slug if slug.nil?
+    end
+
+    def before_create
+      place_in_page_tree
+      super
+    end
 
-      def before_save
-        unless new?
-          if title = self.fields[:title]
-            if title.modified? and !title.blank? and self.class.is_default_slug?(slug)
-              self.slug = title.value
-            end
+    def before_save
+      unless new?
+        if title = self.fields[:title]
+          if title.modified? and !title.blank? and self.class.is_default_slug?(slug)
+            self.slug = title.value
           end
         end
-        super
       end
+      super
+    end
 
-      def after_save
-        super
-        check_for_path_changes
-      end
+    def after_save
+      super
+      check_for_path_changes
+    end
 
-      def default_slug
-        self.class.generate_default_slug
-      end
+    def default_slug
+      self.class.generate_default_slug
+    end
 
-      def parent=(parent)
-        super
-      end
+    def parent=(parent)
+      @__parent_changed = true
+      super
+    end
 
-      def place_in_page_tree
-        if self.parent_id.nil?
-          if Spontaneous::Page.root.nil?
-            make_root
-          end
-        else
-          update_path
+    def place_in_page_tree
+      if self.parent_id.nil?
+        if Spontaneous::Page.root.nil?
+          make_root
         end
+      else
+        update_path
       end
+    end
 
-      def make_root
-        self[:path] = "/"
-        self[:slug] = ""
-        self[:ancestor_path] = ""
-      end
+    def make_root
+      self[:path] = "/"
+      self[:slug] = ""
+      self[:ancestor_path] = ""
+    end
 
-      def ancestor_path
-        (self[:ancestor_path] || "").split(ANCESTOR_SEP).map { |id| id.to_i }
-      end
+    def ancestor_path
+      (self[:ancestor_path] || "").split(ANCESTOR_SEP).map { |id| id.to_i }
+    end
 
-      def root?
-        path == Spontaneous::SLASH
-      end
-      alias_method :is_root?, :root?
+    def root?
+      path == Spontaneous::SLASH
+    end
+    alias_method :is_root?, :root?
 
-      def root
-        Spontaneous::Page.root
-      end
+    def root
+      Spontaneous::Page.root
+    end
 
-      def update_path
-        self.path = calculate_path
-        if parent
-          self[:ancestor_path] = parent.ancestor_path.push(parent.id).join(ANCESTOR_SEP)
-        end
+    def update_path
+      self.path = calculate_path
+      if parent
+        self[:ancestor_path] = parent.ancestor_path.push(parent.id).join(ANCESTOR_SEP)
       end
+    end
 
 
-      def calculate_path
-        if parent.nil?
-          root? ? Spontaneous::SLASH : '' # bad case, no parent but not root
-        else
-          File.join(parent.path, slug)
-        end
-      end
-
-      def slug=(s)
-        if (new_slug = s.to_url) != self.slug
-          @__slug_changed = true
-          self[:slug] = new_slug
-          self.update_path
-        end
+    def calculate_path
+      if parent.nil?
+        root? ? Spontaneous::SLASH : '' # bad case, no parent but not root
+      else
+        File.join(parent.path, slug)
       end
+    end
 
-      def check_for_path_changes
-        if @__slug_changed
-          @__slug_changed = false
-          children.each do |child|
-            child.propagate_path_changes
-          end
-        end
+    def slug=(s)
+      if (new_slug = s.to_url) != self.slug
+        @__slug_changed = true
+        # slugs can be max 255 characters long
+        self[:slug] = new_slug[0..254]
+        self.update_path
       end
+    end
 
-      def propagate_path_changes
-        self.update_path
-        self.save
+    def check_for_path_changes
+      if @__slug_changed
+        @__slug_changed = false
         children.each do |child|
           child.propagate_path_changes
         end
+        aliases.each do |link|
+          link.propagate_path_changes if link.page?
+        end
+      end
+    end
+
+    def propagate_path_changes
+      self.update_path
+      self.save
+      children.each do |child|
+        child.propagate_path_changes
       end
     end
   end

data/lib/spontaneous/plugins/permissions.rb

@@ -1,27 +1,27 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins
   module Permissions
+    extend ActiveSupport::Concern
 
     module ClassMethods
-      def box_readable?(box_name)
-        box_permission(box_name, :read_level)
+      def box_readable?(user, box_name)
+        box_permission(user, box_name, :read_level)
       end
-      def box_writable?(box_name)
-        box_permission(box_name, :write_level)
+      def box_writable?(user, box_name)
+        box_permission(user, box_name, :write_level)
       end
 
-      def field_readable?(field_name)
-        field_permission(field_name, :read_level)
+      def field_readable?(user, field_name)
+        field_permission(user, field_name, :read_level)
       end
 
-      def field_writable?(field_name)
-        field_permission(field_name, :write_level)
+      def field_writable?(user, field_name)
+        field_permission(user, field_name, :write_level)
       end
 
-      def field_permission(field_name, test)
-        return true unless user = Spontaneous::Permissions.active_user
+      def field_permission(user, field_name, test)
+        return true unless user# = Spontaneous::Permissions.active_user
         if field = field_prototypes[field_name.to_sym]
           user.level >= field.__send__(test)
         else
@@ -29,8 +29,8 @@ module Spontaneous::Plugins
         end
       end
 
-      def box_permission(box_name, test)
-        return true unless user = Spontaneous::Permissions.active_user
+      def box_permission(user, box_name, test)
+        return true unless user# = Spontaneous::Permissions.active_user
         if box = boxes[box_name.to_sym]
           user.level >= box.__send__(test)
         else
@@ -40,24 +40,22 @@ module Spontaneous::Plugins
     end # ClassMethods
 
 
-    module InstanceMethods
-      def field_readable?(field_name)
-        self.class.field_readable?(field_name)
-      end
+    # InstanceMethods
 
-      def field_writable?(field_name)
-        self.class.field_writable?(field_name)
-      end
+    def field_readable?(user, field_name)
+      self.class.field_readable?(user, field_name)
+    end
 
-      def box_writable?(box_name)
-        self.class.box_writable?(box_name)
-      end
+    def field_writable?(user, field_name)
+      self.class.field_writable?(user, field_name)
+    end
 
-      def box_readable?(box_name)
-        self.class.box_readable?(box_name)
-      end
-    end # InstanceMethods
+    def box_writable?(user, box_name)
+      self.class.box_writable?(user, box_name)
+    end
 
+    def box_readable?(user, box_name)
+      self.class.box_readable?(user, box_name)
+    end
   end # Permissions
 end # Spontaneous::Plugins
-