spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/plugins/application/features.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Application
+  module Features
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def register_back_controller(namespace, controller_class)
+        instance.register_back_controller(namespace, controller_class)
+      end
+
+      def register_front_controller(namespace, controller_class)
+        instance.register_front_controller(namespace, controller_class)
+      end
+    end # ClassMethods
+  end # Features
+end

data/lib/spontaneous/plugins/application/paths.rb

@@ -1,11 +1,8 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins::Application
   module Paths
-
-    def self.configure(base)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       def load_paths
@@ -28,9 +25,9 @@ module Spontaneous::Plugins::Application
         relative_dir(root / "config", *path)
       end
 
-      def template_root=(template_root)
-        Spot::Render.template_root = template_root.nil? ? nil : File.expand_path(template_root)
-      end
+      # def template_root=(template_root)
+      #   Spot::Render.template_root = template_root.nil? ? nil : File.expand_path(template_root)
+      # end
 
       def template_root(*path)
         relative_dir(Spot::Render.template_root, *path)
@@ -50,26 +47,29 @@ module Spontaneous::Plugins::Application
       end
 
       def schema_map
-        Spontaneous::Schema.schema_map_file
+        Spontaneous.schema.schema_map_file
       end
 
       def schema_map=(path)
-        Spontaneous::Schema.schema_map_file = path
+        Spontaneous.schema.schema_map_file = path
       end
 
-      def media_dir=(dir)
-        @media_dir = File.expand_path(dir)
-      end
+      # def media_dir=(dir)
+      #   @media_dir = File.expand_path(dir)
+      # end
 
       def media_dir(*path)
-        @media_dir ||= File.expand_path(root / "cache/media")
-        relative_dir(@media_dir, *path)
+        Spontaneous.instance.media_dir(*path)
       end
 
       def media_path(*args)
         Spontaneous::Media.media_path(*args)
       end
 
+      def cache_dir(*path)
+        Spontaneous.instance.cache_dir(*path)
+      end
+
       def shard_path(hash=nil)
         if hash
           path = ['tmp', hash[0..1], hash[2..3], hash]
@@ -82,26 +82,23 @@ module Spontaneous::Plugins::Application
       end
 
       def root(*path)
-        @root ||= File.expand_path(ENV[Spontaneous::SPOT_ROOT] || Dir.pwd)
-        relative_dir(@root, *path)
+        Spontaneous.instance.root(*path)
       end
 
-      def root=(root)
-        @root = File.expand_path(root)
-      end
+      # def root=(root)
+      #   @root = File.expand_path(root)
+      # end
 
       def revision_root(*path)
-        @revision_dir ||= File.expand_path(root / 'cache/revisions')
-        relative_dir(@revision_dir, *path)
+        Spontaneous.instance.revision_root(*path)
       end
 
-      def revision_root=(revision_dir)
-        @revision_dir = File.expand_path(revision_dir)
-      end
+      # def revision_root=(revision_dir)
+      #   @revision_dir = File.expand_path(revision_dir)
+      # end
 
-      def revision_dir(revision=nil, root = revision_root)
-        return root / 'current' if revision.nil?
-        root / revision.to_s.rjust(5, "0")
+      def revision_dir(revision=nil, root = nil)
+        Spontaneous.instance.revision_dir(revision, root)
       end
 
       def gem_dir(*path)
@@ -126,12 +123,9 @@ module Spontaneous::Plugins::Application
         relative_dir(application_dir / "css", *path)
       end
 
-      private
-
       def relative_dir(root, *path)
-        File.join(root, *path)
+        File.join(root, *path.map { |p| p.to_s })
       end
     end # ClassMethods
   end # Paths
 end
-

data/lib/spontaneous/plugins/application/render.rb

@@ -1,13 +1,10 @@
 # encoding: UTF-8
 
-
 require 'cutaneous'
 
 module Spontaneous::Plugins::Application
   module Render
-
-    def self.configure(base)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       attr_accessor :render_engine
@@ -26,4 +23,3 @@ module Spontaneous::Plugins::Application
     end # ClassMethods
   end # Render
 end # Spontaneous::Plugins::Application
-

data/lib/spontaneous/plugins/application/serialisation.rb

@@ -2,6 +2,8 @@
 
 module Spontaneous::Plugins::Application
   module Serialisation
+    extend ActiveSupport::Concern
+
     module ClassMethods
       include Spontaneous::JSON
       def serialise_http(object)

data/lib/spontaneous/plugins/application/state.rb

@@ -1,22 +1,20 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins::Application
   module State
-
-    def self.configure(base)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
-
       def init(options={})
         # return false if loaded?
         self.environment = (options.delete(:environment) || ENV["SPOT_ENV"] || :development)
         self.mode = options.delete(:mode) || ENV["SPOT_MODE"] || :back
+        root = options.delete(:root) || ENV["SPOT_ROOT"] || Dir.pwd
+        site = Spontaneous::Site.instantiate(root, environment, mode)
         Spontaneous::Logger.setup(:log_level => options[:log_level], :logfile => options[:logfile], :cli => options[:cli])
-        Spontaneous.instance = Spontaneous::Site.instantiate(root, environment, mode)
-        Spontaneous.instance.initialize!
-        Spontaneous::Schema.validate! if self.mode == :console
+        site.initialize!
+        site.schema.validate! if self.mode == :console
+        logger.warn "Auto login is enabled and set to '#{site.config.auto_login}'. Please ensure this is disabled in production mode by removing the 'auto_login' setting from your environment file." if site.config.auto_login and mode == :back
         Thread.current[:spontaneous_loaded] = true
       end
 
@@ -83,4 +81,3 @@ module Spontaneous::Plugins::Application
     end # ClassMethods
   end # State
 end
-

data/lib/spontaneous/plugins/boxes.rb

@@ -2,19 +2,30 @@
 
 module Spontaneous::Plugins
   module Boxes
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def box(name, options = {}, &block)
         name = name.to_sym
-        unless boxes.key?(name)
-          box_prototypes[name] = Spontaneous::Prototypes::BoxPrototype.new(self, name, options, &block)
-          unless method_defined?(name)
-            class_eval <<-BOX
-              def #{name}
-                boxes[:#{name}]
-              end
-            BOX
-          end
+        prototype = nil
+        options[:group] = @box_group if @box_group
+
+        if existing_prototype = boxes[name]
+          prototype = existing_prototype.merge(self, options, &block)
+        else
+          prototype = Spontaneous::Prototypes::BoxPrototype.new(self, name, options, &block)
         end
+
+        box_prototypes[name] = prototype
+
+        unless method_defined?(name)
+          class_eval <<-BOX
+            def #{name}
+              boxes[:#{name}]
+            end
+          BOX
+        end
+        prototype
       end
 
       def boxes
@@ -36,49 +47,63 @@ module Spontaneous::Plugins
       def box?(box_name)
         box_prototypes.key?(box_name.to_sym)
       end
-    end
-
-    module InstanceMethods
 
-      def reload
-        @boxes = nil
-        super
+      def is_box?
+        false
       end
 
-      def boxes(*args)
-        @boxes ||= Spontaneous::Collections::BoxSet.new(self)
+      def box_group(name, &block)
+        @box_group = name #box_groups[name.to_sym]
+        yield if block_given?
+      ensure
+        @box_group = nil
       end
 
-      def iterable
-        boxes
+      def box_position(box_prototype)
+        box_prototypes.index(box_prototype)
       end
+    end # ClassMethods
 
-      def box?(box_name)
-        self.class.box?(box_name.to_sym)
-      end
+    # InstanceMethods
 
-      def box_data(box)
-        # TODO: use schema id to retrieve box data
-        box_id = box.schema_id.to_s
-        (self.box_store || []).detect { |data| data[:box_id] == box_id } || {}
-      end
+    def reload
+      @boxes = nil
+      super
+    end
 
-      def box_field_store(box)
-        box_data(box)[:fields]
-      end
+    def boxes(*args)
+      @boxes ||= Spontaneous::Collections::BoxSet.new(self)
+    end
 
-      def box_modified!(modified_box)
-        self.box_store = serialize_boxes
-      end
+    def iterable
+      boxes
+    end
 
-      def serialize_boxes
-        boxes.map { |box| box.serialize_db }
-      end
 
-      def box_style_id(box_name)
-        nil
-      end
+    def box?(box_name)
+      self.class.box?(box_name.to_sym)
+    end
+
+    def box_data(box)
+      # TODO: use schema id to retrieve box data
+      box_id = box.schema_id.to_s
+      (self.box_store || []).detect { |data| data[:box_id] == box_id } || {}
+    end
+
+    def box_field_store(box)
+      box_data(box)[:fields]
+    end
+
+    def box_modified!(modified_box)
+      self.box_store = serialize_boxes
+    end
+
+    def serialize_boxes
+      boxes.map { |box| box.serialize_db }
+    end
+
+    def box_style_id(box_name)
+      nil
     end
   end
 end
-

data/lib/spontaneous/plugins/controllers.rb

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins
   module Controllers
-    ACTION_SEPARATOR = "@".freeze
+    extend ActiveSupport::Concern
 
+    ACTION_SEPARATOR = "@".freeze
 
     module ClassMethods
       def controllers
@@ -29,24 +29,24 @@ module Spontaneous::Plugins
       end
     end # ClassMethods
 
-    module InstanceMethods
-      # resolve and call the relevant action handler and return the results to the controller
-      def process_action(action_path, env, format)
-        env = env.dup
-        namespace, *p = action_path.split(S::Constants::SLASH)
-        path = [S::Constants::EMPTY].concat(p).join(S::Constants::SLASH)
-        env[S::Constants::PATH_INFO] = path
-        controller_class = self.class.controllers[namespace.to_sym]
-        return 404 unless controller_class
-        app = controller_class.new(self, format)
-        app.call(env)
-      end
-
-      # generate an action URL of the form
-      # <path to page>/@<action namespace>/<action path>
-      def action_url(namespace, path)
-        [self.path, "#{ACTION_SEPARATOR}#{namespace}", path].join(S::Constants::SLASH).gsub(%r{//}, '/')
-      end
-    end # InstanceMethods
-  end # Actions
+    # InstanceMethods
+
+    # resolve and call the relevant action handler and return the results to the controller
+    def process_action(action_path, env, format)
+      env = env.dup
+      namespace, *p = action_path.split(S::Constants::SLASH)
+      path = [S::Constants::EMPTY].concat(p).join(S::Constants::SLASH)
+      env[S::Constants::PATH_INFO] = path
+      controller_class = self.class.controllers[namespace.to_sym]
+      return 404 unless controller_class
+      app = controller_class.new(self, format)
+      app.call(env)
+    end
+
+    # generate an action URL of the form
+    # <path to page>/@<action namespace>/<action path>
+    def action_url(namespace, path)
+      [self.path, "#{ACTION_SEPARATOR}#{namespace}", path].join(S::Constants::SLASH).gsub(%r{//}, '/')
+    end
+  end # Controllers
 end

data/lib/spontaneous/plugins/entries.rb

@@ -2,192 +2,191 @@
 
 module Spontaneous::Plugins
   module Entries
+    extend ActiveSupport::Concern
 
-    def self.configure(base)
-      base.__send__(:alias_method,  :<<, :push)
+    included do
+      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)
+    #
+    #     def self.configure(base)
+    #       base.__send__(:alias_method,  :<<, :push)
+    #     end
+
+    # InstanceMethods
+
+    VISIBILITY_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 owner
+        self.page = owner.page if page.nil?
+        if page?
+          self.depth = parent ? ((parent.depth || 0) + 1) : 0
+        else
+          self.depth = (owner.content_depth || 0) + 1
         end
-        super()
-      end
-
-      def before_destroy
-        recursive_destroy
-        super
       end
+      super
+    end
 
-      def recursive_destroy
-        all_pieces.destroy
+    def after_save
+      pieces.each do |entry|
+        entry.save if entry.modified?
       end
+      super
+    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
+    def destroy(remove_owner_entry=true, owner=nil)
+      owner ||= self.owner
+      if owner && remove_owner_entry
+        owner.destroy_entry!(self)
       end
+      super()
+    end
 
-      def content_depth
-        depth
-      end
+    def before_destroy
+      recursive_destroy
+      super
+    end
 
-      def entry_modified!(modified_entry)
-        self.entry_store = all_pieces.serialize_db
-      end
+    def recursive_destroy
+      all_pieces.destroy
+    end
 
-      def pieces
-        if Spontaneous::Content.visible_only?
-          visible_pieces
-        else
-          all_pieces
-        end
-      end
+    def destroy_entry!(entry)
+      pieces.remove(entry)
+      # save the owner because it won't be obvious to the caller
+      # that content other than the destroyed object will have been
+      # modified
+      self.save
+    end
 
-      # ensure that all access to pieces is through their corresponding entry
-      # alias_method :pieces, :entries
+    def content_depth
+      depth
+    end
 
-      def all_pieces
-        @all_pieces ||= Spontaneous::Collections::EntrySet.new(self, entry_store)
-      end
+    def entry_modified!(modified_entry)
+      self.entry_store = all_pieces.serialize_db
+    end
 
-      def visible_pieces
-        @visible_pieces ||= all_pieces.visible!
-      end
+    def pieces
+      return visible_pieces if Spontaneous::Content.visible_only?
+      all_pieces
+    end
 
-      protected(:all_pieces, :visible_pieces)
+    # ensure that all access to pieces is through their corresponding entry
+    # alias_method :pieces, :entries
 
-      def reload
-        @all_pieces = @visible_pieces = nil
-        super
-      end
+    def all_pieces
+      @all_pieces ||= Spontaneous::Collections::EntrySet.new(self, entry_store)
+    end
 
+    def visible_pieces
+      @visible_pieces ||= all_pieces.visible!
+    end
 
-      def first
-        pieces.first
-      end
+    protected(:all_pieces, :visible_pieces)
 
-      def last
-        pieces.last
-      end
+    def reload
+      @all_pieces = @visible_pieces = nil
+      super
+    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 first
+      pieces.first
+    end
 
+    def last
+      pieces.last
+    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 push(page_or_piece)
+      insert(-1, page_or_piece)
+    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)
+    def insert(index, page_or_piece, box)
+      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_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
+    def insert_page(index, child_page, box)
+      child_page.owner = self
+      if page
+        child_page.depth = page.depth + 1
+        page.unordered_children << child_page
+        child_page.parent = page
+        child_page.update_path
       end
+      insert_with_style(:page, index, child_page, box)
+    end
 
-      def update_position(position)
-        entry.set_position(position)
-        container.save
-      end
+    def insert_piece(index, piece, box)
+      piece.owner = self
+      piece.page = page if page
+      piece.depth = (content_depth || 0) + 1
+      insert_with_style(:piece, index, piece, box)
+    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 insert_with_style(type, index, content, box)
+      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, box, 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 style_for_content(content, box = nil)
-        if box
-          box.style_for_content(content)
+    def update_position(position)
+      entry.set_position(position)
+      owner.save
+    end
 
-        else
-          content.default_style
-        end
+    def set_position(new_position)
+      if box
+        box.set_position(self, new_position)
+      else
+        owner.pieces.set_position(self, new_position)
       end
+    end
 
-      def available_styles(content)
-        content.class.styles
+    def style_for_content(content, box = nil)
+      if box
+        box.style_for_content(content)
+      else
+        content.default_style
       end
+    end
 
-      def container=(container)
-        super
-        self[:content_path] = [container.content_path, container.id].compact.join(CONTENT_PATH_SEP)
-      end
+    def available_styles(content)
+      content.class.styles
+    end
 
-    end # InstanceMethods
+    def owner=(owner)
+      super
+      self[:visibility_path] = [owner.visibility_path, owner.id].compact.join(VISIBILITY_PATH_SEP)
+    end
   end # Entries
 end # Spontaneous::Plugins
-