spontaneous 0.1.0.alpha1

data/lib/spontaneous/plugins/schema_title.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module SchemaTitle
+
+    module ClassMethods
+      def class_name_with_fallback
+        n = name
+        if n.nil? or n.empty?
+          n = "ContentClass#{object_id}"
+        end
+        n
+      end
+
+      def title(custom_title=nil)
+        self.title = custom_title if custom_title
+        @title or default_title
+      end
+
+      def default_title
+        n = class_name_with_fallback.split(/::/).last.gsub(/([A-Z]+)([A-Z][a-z])/,'\1 \2')
+        n.gsub!(/([a-z\d])([A-Z])/,'\1 \2')
+        n
+      end
+
+      def title=(title)
+        @title = title
+      end
+    end
+
+  end
+end
+

data/lib/spontaneous/plugins/serialisation.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Serialisation
+
+    module ClassMethods
+      def export
+        {
+          :type=> self.ui_class,
+          :id => self.schema_id.to_s,
+          :is_page => self.page?,
+          :is_alias => self.alias?,
+          :title=> self.title,
+          :fields => readable_fields.map { |name| field_prototypes[name].export },
+          :styles => readable_styles.map { |style| style.export },
+          :boxes => readable_boxes.map { |box| box.export },
+          :source => self.__source_file
+        }
+      end
+
+      def readable_styles
+        styles
+      end
+
+      def readable_boxes
+        boxes.select { |box| box.readable? }
+      end
+
+      def readable_fields
+        field_names.select { |name| field_readable?(name) }
+      end
+
+      def serialise_http
+        Spontaneous.serialise_http(export)
+      end
+
+    end # ClassMethods
+
+    module InstanceMethods
+      def shallow_export
+        {
+          :id => id,
+          :type => self.class.ui_class,
+          :type_id => self.class.schema_id.to_s,
+          :is_page => page?,
+          :hidden => (hidden? ? true : false),
+          :depth => content_depth,
+          :fields  => fields.export,
+          :label => label
+        }
+      end
+
+      def export
+        shallow_export.merge({
+          :boxes => self.class.readable_boxes.map { |box| boxes[box.name].export }
+        })
+      end
+
+
+      def serialise_http
+        Spontaneous.serialise_http(export)
+      end
+    end # InstanceMethods
+  end # Serialisation
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/site/instance.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Site
+  module Instance
+    module ClassMethods
+      extend Forwardable
+
+      @@instance = nil
+
+      def instantiate(root, env, mode)
+        @@instance = Spontaneous::Site.new(root, env, mode)
+      end
+
+      def instance
+        @@instance
+      end
+
+      def_delegators :instance, :config, :database, :database=
+    end # ClassMethods
+  end # Map
+end
+

data/lib/spontaneous/plugins/site/map.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Site
+  module Map
+    module ClassMethods
+
+      def map(root_id=nil)
+        page = \
+          if root_id.nil?
+            Spontaneous::Page.root
+          else
+            Spontaneous::Content[root_id]
+          end
+        return nil unless page
+        page.map_entry
+      end
+    end # ClassMethods
+  end # Map
+end

data/lib/spontaneous/plugins/site/publishing.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Site
+    module Publishing
+      module ClassMethods
+
+        def default_publishing_method
+          resolve_publishing_method(Spontaneous::Site.config.publishing_method || :immediate)
+        end
+
+        def publishing_method
+          @publishing_method ||= default_publishing_method
+        end
+
+        def publishing_method=(method)
+          @publishing_method = resolve_publishing_method(method)
+        end
+
+        def resolve_publishing_method(method)
+          klass_name = method.to_s.camelize
+          begin
+            S::Publishing.const_get(klass_name)
+          rescue NameError => e
+            puts "Unknown method #{method} (#{klass_name})"
+            S::Publishing::Immediate
+          end
+        end
+
+        def publish_changes(change_list=nil)
+          publishing_method.new(self.revision).publish_changes(change_list)
+        end
+
+        def publish_all
+          publishing_method.new(self.revision).publish_all
+        end
+
+        def publishing_status
+          status = rest = nil
+          # if r = S::Site.pending_revision
+            status, *rest = publishing_method.status.split(':')
+            rest = rest.join(':')
+          # end
+          Hash[[:status, :progress].zip([status, rest])] rescue ""
+        end
+
+        def publishing_status=(status)
+          publishing_method.status = status
+        end
+
+        def with_published(&block)
+          S::Content.with_published(&block)
+        end
+
+        protected
+
+        def set_published_revision(revision)
+          instance = S::State.instance
+          instance.published_revision = revision
+          instance.revision = revision + 1
+          instance.save
+        end
+
+        def pending_revision=(revision)
+          instance = S::State.instance
+          instance.pending_revision = revision
+          instance.save
+        end
+      end # ClassMethods
+    end # Publishing
+  end # Site
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/site/revisions.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Site
+    module Revisions
+      module ClassMethods
+        def working_revision
+          Spontaneous::State.revision
+        end
+
+        def revision
+          Spontaneous::State.revision
+        end
+
+        def published_revision
+          Spontaneous::State.published_revision
+        end
+
+        def pending_revision
+          Spontaneous::State.pending_revision
+        end
+
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/site/selectors.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Site
+    module Selectors
+      module ClassMethods
+        def root
+          Spontaneous::Page.root
+        end
+
+        def [](path_or_uid)
+          case path_or_uid
+          when /^\//
+            by_path(path_or_uid)
+          when /^#/
+            by_uid(path_or_uid[1..-1])
+          else
+            by_uid(path_or_uid)
+          end
+        end
+
+        def by_path(path)
+          Spontaneous::Page.path(path)
+        end
+
+        def by_uid(uid)
+          Spontaneous::Page.uid(uid)
+        end
+
+        def method_missing(method, *args)
+          if page = self[method.to_s]
+            page
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/site_map.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module SiteMap
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      def map_children
+        self.children.map { |c| c.map_entry }
+      end
+
+      def map_entry
+        shallow_map_entry.merge({
+          :children => self.children.map {|c| c.shallow_map_entry },
+          :generation => self.generation.map {|c| c.shallow_map_entry },
+          :ancestors => self.ancestors.map {|c| c.shallow_map_entry },
+        })
+      end
+      def shallow_map_entry
+        {
+          :id => id,
+          :title => fields.title.value,
+          :path => path,
+          :type => self.class.ui_class,
+          :type_id => self.class.schema_id,
+          :children => self.children.length,
+          :depth => depth
+        }
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/styles.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Styles
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+      def style(name, options={})
+        name = name.to_sym
+        styles[name] = Spontaneous::Prototypes::StylePrototype.new(self, name, options)
+      end
+
+      def style_prototypes
+        @style_prototypes ||= Spontaneous::Collections::StyleSet.new(self)
+      end
+
+      alias_method :styles, :style_prototypes
+
+      def resolve_style(style_sid)
+        if style_sid.blank?
+          default_style
+        else
+          find_style(style_sid)
+        end
+      end
+
+      def default_style
+        if styles.empty?
+          style = style_class::Default.new(self)
+        else
+          style = (style_prototypes.detect { |prototype| prototype.default? } || style_prototypes.first).style(self)
+        end
+      end
+
+      def style_class
+        Spontaneous::Style
+      end
+
+
+      def find_style(style_sid)
+        if prototype = style_prototypes.sid(style_sid)
+          prototype.style(self)
+        end
+      end
+
+      def find_named_style(style_name)
+        style_prototypes[style_name.to_sym]
+      end
+
+      alias_method :get_style, :find_named_style
+
+      def template(format=:html, template_string=nil)
+        if template_string.nil?
+          template_string = format
+          format = :html
+        end
+        inline_templates[format.to_sym] = template_string
+      end
+
+      def inline_templates
+        @inline_templates ||= {}
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+
+      def style=(style)
+        self.style_sid = style_to_schema_id(style)
+      end
+
+      # converts a symbol or string into a Schema::UID instance
+      def style_to_schema_id(style)
+        return nil if style.nil?
+        sid = nil
+        if style.respond_to?(:schema_id)
+          sid = style.schema_id
+        else
+          if Spontaneous::Schema::UID === style
+            sid = style
+          else
+            if s = self.find_named_style(style)
+              sid = s.schema_id
+            end
+          end
+        end
+      end
+
+      def find_named_style(style_name)
+        self.class.find_named_style(style_name)
+      end
+
+      def style
+        resolve_style(self.style_sid)
+      end
+
+      def default_style
+        self.class.default_style
+      end
+
+      def resolve_style(style_sid)
+        self.class.resolve_style(style_sid)
+      end
+
+      def styles
+        self.class.styles
+      end
+
+      def template(format = :html)
+        style.template(format)
+      end
+
+
+    end # InstanceMethods
+
+  end
+end
+

data/lib/spontaneous/plugins/supertype.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Supertype
+    module ClassMethods
+      def supertype
+        superclass
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/visibility.rb

@@ -0,0 +1,151 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Visibility
+    S = Spontaneous unless defined?(S)
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+      @@visible_filter = false
+
+      def _set_visible_dataset!
+        @_saved_dataset ||= self.dataset
+        ds = self.dataset.filter(:hidden => false)
+        @dataset = ds
+        # set_dataset clears the row_proc which desroys the STI
+        # self.set_dataset(ds)
+      end
+
+      def _restore_dataset!
+        # self.set_dataset( self.dataset.unfiltered) if @_saved_dataset
+        @dataset = @_saved_dataset if @_saved_dataset
+        @_saved_dataset = nil
+      end
+
+      def _content_classes
+        [Spontaneous::Content, Spontaneous::Page, Spontaneous::Piece] + Spontaneous::Schema.content_classes
+      end
+
+      def _unfiltered_dataset
+        @_saved_dataset or dataset
+      end
+
+      def with_visible(&block)
+        if @@visible_filter
+          yield
+        else
+          begin
+            _content_classes.each { |content_class| content_class._set_visible_dataset! }
+            @@visible_filter = true
+            yield
+          ensure
+            @@visible_filter = false
+            _content_classes.each { |content_class| content_class._restore_dataset! }
+          end
+        end
+      end
+
+      def visible_only?
+        @@visible_filter
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      def visible?
+        !self.hidden
+      end
+
+      def hidden?
+        self.hidden
+      end
+
+      def hide!
+        set_visible!(false)
+      end
+
+      def show!
+        set_visible!(true)
+      end
+
+      def toggle_visibility!
+        if hidden?
+          show!
+        else
+          hide!
+        end
+      end
+
+      ##
+      # Is true when the current object is hidden independently of its ancestors
+      # and false when hidden because one of its ancestors is hidden (so to show
+      # this you need to show that ancestor)
+      def showable?
+        hidden? && hidden_origin.blank?
+      end
+
+      def visible=(visible)
+        protect_root_visibility!
+        set_visible(visible)
+      end
+
+
+      protected
+
+      def set_visible!(state)
+        self.set_visible(state)
+        self.save
+        self
+      end
+
+      def set_visible(visible)
+        protect_root_visibility!
+        if self.visible? != visible
+          raise Spontaneous::NotShowable.new(self, hidden_origin) if hidden? && visible && !showable?
+          self[:hidden] = !visible
+          self[:hidden_origin] = nil
+          @_visibility_modified = true
+        end
+      end
+
+      def after_save
+        super
+        if @_visibility_modified
+          hide_descendents(self.visible?)
+          @_visibility_modified = false
+        end
+      end
+
+      def hide_descendents(visible)
+        path_like = :content_path.like("#{self[:content_path]}.#{self.id}%")
+        origin = visible ? nil : self.id
+        dataset = Spontaneous::Content.filter(path_like).filter(:hidden => visible)
+        # if a child item has been made invisible *before* its parent then it exists
+        # with hidden = true and hidden_origin = nil
+        if visible
+          dataset = dataset.filter(:hidden_origin => self.id)
+        end
+        dataset.update(:hidden => !visible, :hidden_origin => origin)
+
+        ## I'm saving these for posterity: I worked out some Sequel magic and I don't want to lose it
+        #
+        # Spontaneous::Content.from(:content___p).filter(path_like).update(:visible => visible, :hidden_origin => origin)
+        # Spontaneous::Content.filter(:page_id => self.id).set(:visible => visible, :hidden_origin => origin)
+        ## Update with join:
+        # Spontaneous::Content.from(:content___n, :content___p).filter(path_like).filter(:n__page_id => :p__id).set(:n__visible => visible, :n__hidden_origin => origin)
+      end
+
+      def protect_root_visibility!
+        if self.is_page? && self.is_root?
+          raise "Root page is not hidable"
+        end
+      end
+    end # InstanceMethods
+
+  end
+end
+
+
+

data/lib/spontaneous/plugins.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+
+# thanks to @jnunemaker
+# http://github.com/jnunemaker/mongomapper/blob/master/lib/mongo_mapper/plugins.rb
+
+module Spontaneous
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      extend  mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods  if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)           if mod.respond_to?(:configure)
+      plugins << mod
+    end
+  end
+end