spontaneous 0.1.0.alpha1

data/lib/spontaneous/plugins/page_tree.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module PageTree
+
+    module InstanceMethods
+      def ancestors
+        ancestor_path.map { |id| Spontaneous::Content[id] }
+      end
+
+      def ancestor(depth)
+        ancestors[depth]
+      end
+
+      def generation
+        parent ? parent.children : [root]
+      end
+
+      def siblings
+        generation.reject { |p| p === self }
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/paths.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Paths
+
+    module ClassMethods
+      def generate_default_slug
+        "page-#{Time.now.strftime('%Y%m%d-%H%M%S')}"
+      end
+
+      def is_default_slug?(slug)
+        /^page-\d{8}-\d{6}$/ === slug
+      end
+    end
+
+    module InstanceMethods
+      ANCESTOR_SEP = "."
+
+      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
+          end
+        end
+        super
+      end
+
+      def after_save
+        super
+        check_for_path_changes
+      end
+
+      def default_slug
+        self.class.generate_default_slug
+      end
+
+      def parent=(parent)
+        super
+      end
+
+      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 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
+        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
+      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
+      end
+
+      def check_for_path_changes
+        if @__slug_changed
+          @__slug_changed = false
+          children.each do |child|
+            child.propagate_path_changes
+          end
+        end
+      end
+
+      def propagate_path_changes
+        self.update_path
+        self.save
+        children.each do |child|
+          child.propagate_path_changes
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/permissions.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Permissions
+
+    module ClassMethods
+      def box_readable?(box_name)
+        box_permission(box_name, :read_level)
+      end
+      def box_writable?(box_name)
+        box_permission(box_name, :write_level)
+      end
+
+      def field_readable?(field_name)
+        field_permission(field_name, :read_level)
+      end
+
+      def field_writable?(field_name)
+        field_permission(field_name, :write_level)
+      end
+
+      def field_permission(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
+          nil # or perhaps throw error
+        end
+      end
+
+      def box_permission(box_name, test)
+        return true unless user = Spontaneous::Permissions.active_user
+        if box = boxes[box_name.to_sym]
+          user.level >= box.__send__(test)
+        else
+          nil # or perhaps throw error
+        end
+      end
+    end # ClassMethods
+
+
+    module InstanceMethods
+      def field_readable?(field_name)
+        self.class.field_readable?(field_name)
+      end
+
+      def field_writable?(field_name)
+        self.class.field_writable?(field_name)
+      end
+
+      def box_writable?(box_name)
+        self.class.box_writable?(box_name)
+      end
+
+      def box_readable?(box_name)
+        self.class.box_readable?(box_name)
+      end
+    end # InstanceMethods
+
+  end # Permissions
+end # Spontaneous::Plugins
+

data/lib/spontaneous/plugins/prototypes.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Prototypes
+    S = Spontaneous unless defined?(S)
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+
+      ## this is the Sequel default:
+      #
+      # def create(values = {}, &block)
+      #   new(values, &block).save
+      # end
+
+      def create_without_prototype(values = {}, &block)
+        create(false, values, &block)
+      end
+
+      ##
+      # Create a new content instance
+      def create(*args, &block)
+        first = args.shift
+        prototype = values = nil
+        case first
+        when Symbol, false
+          prototype = first
+          values = args.shift || {}
+        when Hash
+          values = first
+        else
+          values = {}
+        end
+        new(values.merge(:_prototype => prototype), &block).save
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+
+      def after_create
+        super
+        apply_prototype
+      end
+
+      protected
+
+      DEFAULT_PROTOTYPE_METHOD = :prototype unless defined?(DEFAULT_PROTOTYPE_METHOD)
+
+      def apply_prototype
+        return if _prototype == false
+        prototype_method = DEFAULT_PROTOTYPE_METHOD
+        unless _prototype.blank?
+          prototype_method = "#{_prototype}_prototype".to_sym
+        end
+
+        if respond_to?(prototype_method)
+          self.__send__(prototype_method)
+          save
+        else
+          logger.warn {
+            "Invalid prototype name '#{_prototype}' being passed to class #{self.class}. No method #{prototype_method} available."
+          } unless prototype_method == DEFAULT_PROTOTYPE_METHOD
+        end
+      end
+
+      def _prototype=(prototype)
+        @_prototype = prototype
+      end
+
+      def _prototype
+        @_prototype
+      end
+
+    end # InstanceMethods
+
+  end
+end
+
+
+
+

data/lib/spontaneous/plugins/publishing.rb

@@ -0,0 +1,255 @@
+# encoding: UTF-8
+
+# is this unforgivable?
+# i think it's kinda neat, if a tad fragile (to columns named 'content'...)
+module Sequel
+  class Dataset
+    alias_method :sequel_quote_identifier, :quote_identifier
+
+
+    def quote_identifier(name)
+      if name == :content or name == "content"
+        name = Spontaneous::Content.current_revision_table
+      end
+      sequel_quote_identifier(name)
+    end
+  end
+end
+
+module Spontaneous::Plugins
+  module Publishing
+
+    module ClassMethods
+      @@dataset = nil
+      @@revision = nil
+
+      def current_revision_table
+        revision_table(@@revision)
+      end
+
+      def base_table
+        'content'
+      end
+
+      # make sure that the table name is always the correct revision
+      def simple_table
+        current_revision_table
+      end
+
+      def revision_table(revision=nil)
+        return base_table if revision.nil?
+        "__r#{revision.to_s.rjust(5, '0')}_content"
+      end
+
+      def revision_table?(table_name)
+        /^__r\d{5}_content$/ === table_name.to_s
+      end
+
+      def revision_exists?(revision)
+        database.tables.include?(revision_table(revision).to_sym)
+      end
+
+      def revision
+        @@revision
+      end
+
+      def reset_revision
+        @@revision, @@dataset = revision_stack.first
+        revision_stack.clear
+      end
+
+      def with_revision(revision=nil)
+        revision_push(revision)
+        begin
+          yield
+        ensure
+          revision_pop
+        end if block_given?
+      end
+
+      def with_editable(&block)
+        with_revision(nil, &block)
+      end
+
+      def with_published(&block)
+        revision = Spontaneous::Site.published_revision
+        with_revision(revision, &block)
+      end
+
+      def revision_push(revision)
+        revision_stack.push([@@revision, (@@dataset || self.dataset)])
+        @@dataset = revision_dataset(revision)
+        @@revision = revision
+      end
+
+      def database
+        Spontaneous.database
+      end
+
+      ##
+      # Publish a revision
+      #
+      # If content is a non-empty list of Content ids then this will only publish changes to those
+      # rows (taking the rest of the content from the previous revision)
+      # Pass in a block if you want to tie some bit of post processing to the success or failure
+      # of the publish step (used in the site render stage for example)
+      def publish(revision, content=nil)
+        mark_first_published = Proc.new do |dataset|
+          dataset.update(:first_published_at => Sequel.datetime_class.now, :first_published_revision => revision)
+        end
+
+        mark_published = Proc.new do |dataset|
+          dataset.update(:last_published_at => Sequel.datetime_class.now)
+        end
+        first_published = published = nil
+
+        with_editable do
+          first_published = self.filter(:first_published_at => nil)
+          published = self.filter
+
+          must_publish_all = (content.nil? || (!revision_exists?(revision-1)) || \
+            (content.is_a?(Array) && content.empty?))
+
+          if must_publish_all
+            create_revision(revision)
+          else
+            content = content.map do |c|
+              c.is_a?(Spontaneous::Content) ? c.reload : Spontaneous::Content[c]
+            end.compact
+
+            first_published = first_published.filter(:id => content.map { |c| c.id })
+            published = published.filter(:id => content.map { |c| c.id })
+
+            create_revision(revision, revision-1)
+            content.each do |c|
+              c.sync_to_revision(revision)
+            end
+          end
+
+          # run any passed code and if it fails revert the publish step
+          if block_given?
+            begin
+              with_revision(revision) { yield }
+            rescue Exception => e
+              delete_revision(revision)
+              raise e
+            end
+          end
+
+          with_editable do
+            mark_first_published[first_published]
+            mark_published[published]
+          end
+          with_revision(revision) do
+            mark_first_published[first_published]
+            mark_published[published]
+          end
+        end
+      end
+
+      def publish_all(revision, &block)
+        publish(revision, nil, &block)
+      end
+
+      def create_revision(revision, from_revision=nil)
+        dest_table = revision_table(revision)
+        src_table = revision_table(from_revision)
+        sql = "CREATE TABLE #{dataset.quote_identifier(dest_table)} AS SELECT * FROM #{dataset.quote_identifier(src_table)}"
+        database.run(sql)
+        indexes = database.indexes(base_table)
+        indexes.each do |name, options|
+          columns = options.delete(:columns)
+          database.add_index(dest_table, columns, options)
+        end
+      end
+
+      def delete_revision(revision)
+        return if revision.nil?
+        database.drop_table(revision_table(revision)) if revision_exists?(revision)
+      end
+
+      def delete_all_revisions!
+        database.tables.each do |table|
+          database.drop_table(table) if revision_table?(table)
+        end
+      end
+
+      def revision_pop
+        @@revision, @@dataset = revision_stack.pop
+      end
+
+      def revision_stack
+        @revision_stack ||= []
+      end
+
+      def revision_dataset(revision=nil)
+        Spontaneous.database.dataset.from(revision_table(revision))
+      end
+    end
+
+    module InstanceMethods
+      def after_update
+        super
+        page.modified!(page?) if page
+      end
+
+      # def after_create
+      #   super
+      #   push_page_change
+      # end
+
+      def modified!(caller_is_page)
+        unless caller_is_page
+          self.model.where(:id => self.id).update(:modified_at => Sequel.datetime_class.now)
+        end
+        push_page_change
+      end
+
+      def push_page_change
+        Spontaneous::Change.push(self) if page?
+      end
+
+
+      def with_revision(revision, &block)
+        self.class.with_revision(revision, &block)
+      end
+      def with_editable(&block)
+        self.class.with_editable(&block)
+      end
+
+      def sync_to_revision(revision, origin=true)
+        # 'publish' is a lock to make sure the duplication doesn't cross
+        # page boundaries unless that's necessary (such as in the case
+        # of a page addition)
+        publish = origin || !self.page?
+
+        with_revision(revision) do
+          published_copy = Spontaneous::Content[self.id]
+          if published_copy
+            if publish and published_copy.entry_store
+              pieces_to_delete = published_copy.entry_store - self.entry_store
+              pieces_to_delete.each do |entry|
+                if c = Spontaneous::Content[entry[0]]
+                  c.destroy(false)
+                end
+              end
+            end
+          else # missing content (so force a publish)
+            Spontaneous::Content.insert({:id => self.id})
+            publish = true
+          end
+
+          if publish
+            with_editable do
+              self.pieces.each do |entry|
+                entry.sync_to_revision(revision, false)
+              end
+            end
+            Spontaneous::Content.where(:id => self.id).update(self.values)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/render.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Render
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      def render(format=:html, params={}, *args)
+        if format.is_a?(Hash)
+          params = format
+          format = :html
+        end
+        Spontaneous::Render.render(self, format, params)
+      end
+
+      # [:html].each do |format|
+      #   module_eval("def to_#{format}(*args); render(:#{format}, *args); end")
+      # end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/schema_hierarchy.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module SchemaHierarchy
+    module ClassMethods
+      def schema_validate
+        if schema_id.nil?
+          Spontaneous::Schema.missing_id!(:type, self)
+        else
+          # only need to check internal consistency if class already existed
+          fields.each do |field|
+            if field.schema_id.nil?
+              Spontaneous::Schema.missing_id!(:field, field)
+            end
+          end
+          # boxes don't have boxes
+          if respond_to?(:boxes)
+            boxes.each do |box|
+              if box.schema_id.nil?
+                Spontaneous::Schema.missing_id!(:box, box)
+              end
+            end
+          end
+
+          styles.each do |style|
+            if style.schema_id.nil?
+              Spontaneous::Schema.missing_id!(:style, style)
+            end
+          end
+          if respond_to?(:layouts)
+            layouts.each do |layout|
+              if layout.schema_id.nil?
+                Spontaneous::Schema.missing_id!(:layout, layout)
+              end
+            end
+          end
+        end
+      end
+
+      def schema_reset!
+        @subclasses = nil
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def __source_file=(path)
+        @__source_file = path
+      end
+
+      protected(:__source_file=)
+
+      def __source_file
+        @__source_file
+      end
+
+      def descendents
+        subclasses.map{ |x| [x] + x.descendents}.flatten
+      end
+
+      def inherited(subclass, real_caller = nil)
+        subclass.__source_file = File.expand_path((real_caller || caller[0]).split(':')[0])
+        Spontaneous::Schema.classes << subclass if subclass.schema_class?
+        subclasses << subclass
+        super(subclass)
+      end
+
+      def schema_class?
+        true
+      end
+    end
+  end
+end
+
+

data/lib/spontaneous/plugins/schema_id.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module SchemaId
+
+    module ClassMethods
+      def schema_id
+        Spontaneous::Schema.schema_id(self)
+      end
+
+      def schema_name
+        "type//#{self.name}"
+      end
+
+      def schema_owner
+        nil
+      end
+
+      def owner_sid
+        nil
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      [:type, :style, :box].each do |c|
+        column = "#{c}_sid"
+        self.class_eval(<<-RUBY)
+          def #{column}
+            @_#{column} ||= Spontaneous::Schema::UID[@values[:#{column}]]
+          end
+
+          def #{column}=(sid)
+            @_#{column} = Spontaneous::Schema::UID[sid]
+            @values[:#{column}] = @_#{column}.to_s
+            @_#{column}
+          end
+        RUBY
+      end
+
+      def schema_id
+        self.class.schema_id
+      end
+
+      def schema_name
+        self.class.schema_name
+      end
+
+      def schema_owner
+        self.class.schema_owner
+      end
+
+      def owner_sid
+        self.class.owner_sid
+      end
+    end # InstanceMethods
+  end # SchemaId
+end
+
+
+