spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/plugins/prototypes.rb

@@ -1,15 +1,12 @@
 # encoding: UTF-8
 
-
 module Spontaneous::Plugins
   module Prototypes
-    S = Spontaneous unless defined?(S)
+    extend ActiveSupport::Concern
 
-    def self.configure(base)
-    end
+    DEFAULT_PROTOTYPE_NAME = :__default_prototype unless defined?(DEFAULT_PROTOTYPE_NAME)
 
     module ClassMethods
-
       ## this is the Sequel default:
       #
       # def create(values = {}, &block)
@@ -36,49 +33,57 @@ module Spontaneous::Plugins
         end
         new(values.merge(:_prototype => prototype), &block).save
       end
-    end # ClassMethods
 
-    module InstanceMethods
 
-      def after_create
-        super
-        apply_prototype
+      # Blocks passed to the prototype call are used to create instance methods on the class
+      # This enables the use of `super` within the blocks and solves the otherwise tricky
+      # inheritance implications.
+      def prototype(name = nil, &block)
+        raise Spontaneous::InvalidPrototypeDefinitionError.new \
+          "Prototype definitions must accept one parameter - " \
+          "the content instance which the prototype is about to be applied." \
+          unless block.arity == 1
+        define_method(prototype_method_name(name), &block)
       end
 
-      protected
+      def prototype_method_name(name)
+        return Spontaneous::Plugins::Prototypes::DEFAULT_PROTOTYPE_NAME if name.blank?
+        "_apply_prototype_#{name}"
+      end
+    end # ClassMethods
 
-      DEFAULT_PROTOTYPE_METHOD = :prototype unless defined?(DEFAULT_PROTOTYPE_METHOD)
+    # InstanceMethods
 
-      def apply_prototype
-        return if _prototype == false
-        prototype_method = DEFAULT_PROTOTYPE_METHOD
-        unless _prototype.blank?
-          prototype_method = "#{_prototype}_prototype".to_sym
-        end
+    def after_create
+      super
+      apply_prototype
+    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
+    # Add in an empty default prototype method for subclasses to override
+    define_method(Spontaneous::Plugins::Prototypes::DEFAULT_PROTOTYPE_NAME) { |instance| }
 
-      def _prototype=(prototype)
-        @_prototype = prototype
-      end
+    protected
+
+    def apply_prototype
+      # passing _prototype => false to the initialisation skips the prototype
+      return if _prototype == false
+      method = self.class.prototype_method_name(_prototype)
 
-      def _prototype
-        @_prototype
+      if respond_to?(method)
+        self.send(method, self)
+      else
+        logger.warn {
+          "Invalid prototype name '#{_prototype}' being passed to class #{self.class}."
+        }
       end
+    end
 
-    end # InstanceMethods
+    def _prototype=(prototype)
+      @_prototype = prototype
+    end
 
+    def _prototype
+      @_prototype
+    end
   end
 end
-
-
-
-

data/lib/spontaneous/plugins/publishing.rb

@@ -1,23 +1,9 @@
 # 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
+    extend ActiveSupport::Concern
 
     module ClassMethods
       @@dataset = nil
@@ -53,18 +39,12 @@ module Spontaneous::Plugins
         @@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?
+      def with_revision(revision=nil, &block)
+        saved_revision = @@revision
+        @@revision = revision
+        self.with_table(revision_table(revision), &block)
+      ensure
+        @@revision = saved_revision
       end
 
       def with_editable(&block)
@@ -76,12 +56,6 @@ module Spontaneous::Plugins
         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
@@ -108,7 +82,7 @@ module Spontaneous::Plugins
           published = self.filter
 
           must_publish_all = (content.nil? || (!revision_exists?(revision-1)) || \
-            (content.is_a?(Array) && content.empty?))
+                              (content.is_a?(Array) && content.empty?))
 
           if must_publish_all
             create_revision(revision)
@@ -173,83 +147,65 @@ module Spontaneous::Plugins
           database.drop_table(table) if revision_table?(table)
         end
       end
+    end # ClassMethods
 
-      def revision_pop
-        @@revision, @@dataset = revision_stack.pop
-      end
-
-      def revision_stack
-        @revision_stack ||= []
-      end
+    # InstanceMethods
 
-      def revision_dataset(revision=nil)
-        Spontaneous.database.dataset.from(revision_table(revision))
-      end
+    def after_update
+      super
+      page.modified!(page?) if page
     end
 
-    module InstanceMethods
-      def after_update
-        super
-        page.modified!(page?) if page
+    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 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 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 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
+    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
-          else # missing content (so force a publish)
-            Spontaneous::Content.insert({:id => self.id})
-            publish = true
           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
+        if publish
+          with_editable do
+            self.pieces.each do |entry|
+              entry.sync_to_revision(revision, false)
             end
-            Spontaneous::Content.where(:id => self.id).update(self.values)
           end
+          Spontaneous::Content.where(:id => self.id).update(self.values)
         end
       end
     end
   end
 end
-

data/lib/spontaneous/plugins/render.rb

@@ -2,23 +2,15 @@
 
 module Spontaneous::Plugins
   module Render
+    extend ActiveSupport::Concern
 
-    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)
+    # InstanceMethods
+    def render(format=:html, params={}, *args)
+      if format.is_a?(Hash)
+        params = format
+        format = :html
       end
-
-      # [:html].each do |format|
-      #   module_eval("def to_#{format}(*args); render(:#{format}, *args); end")
-      # end
+      Spontaneous::Render.render(self, format, params, *args)
     end
-  end
+  end # Render
 end
-

data/lib/spontaneous/plugins/schema_hierarchy.rb

@@ -2,47 +2,45 @@
 
 module Spontaneous::Plugins
   module SchemaHierarchy
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def schema_validate
         if schema_id.nil?
-          Spontaneous::Schema.missing_id!(:type, self)
+          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)
+            if field.owner == self and 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)
+              if box.owner == self and 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)
+            if style.owner == self and 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)
+              if layout.owner == self and layout.schema_id.nil?
+                Spontaneous.schema.missing_id!(:layout, layout)
               end
             end
           end
         end
       end
 
+      # TODO: Delete this?
       def schema_reset!
-        @subclasses = nil
-      end
-
-      def subclasses
-        @subclasses ||= []
       end
 
       def __source_file=(path)
@@ -55,22 +53,23 @@ module Spontaneous::Plugins
         @__source_file
       end
 
+      def subclasses
+        Spontaneous.schema.subclasses_of(self)
+      end
+
       def descendents
-        subclasses.map{ |x| [x] + x.descendents}.flatten
+        Spontaneous.schema.descendents_of(self)
       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
+        Spontaneous.schema.add_class(self, subclass)# if subclass.schema_class?
         super(subclass)
       end
 
       def schema_class?
         true
       end
-    end
-  end
+    end # ClassMethods
+  end # SchemaHierarchy
 end
-
-

data/lib/spontaneous/plugins/schema_id.rb

@@ -2,10 +2,11 @@
 
 module Spontaneous::Plugins
   module SchemaId
+    extend ActiveSupport::Concern
 
     module ClassMethods
       def schema_id
-        Spontaneous::Schema.schema_id(self)
+        Spontaneous.instance.schema_id(self)
       end
 
       def schema_name
@@ -19,42 +20,49 @@ module Spontaneous::Plugins
       def owner_sid
         nil
       end
+
+      # In the case where a new class has been added to the schema
+      # the STI values have been set up on a class whose schema id is undefined
+      # so we need to correct this once a new ID has been generated
+      # Bit dodgy, what I should do instead is rewrite the STI code to always defer
+      # to the schema for its values
+      def update_schema_id(new_id)
+        sti_key_array << new_id.to_s
+        superclass.sti_subclass_added(new_id.to_s, self) if superclass
+      end
     end # ClassMethods
 
-    module InstanceMethods
-      [:type, :style, :box].each do |c|
-        column = "#{c}_sid"
-        self.class_eval(<<-RUBY)
+    # InstanceMethods
+
+    [:type, :style, :box].each do |c|
+      column = "#{c}_sid"
+      self.class_eval(<<-RUBY)
           def #{column}
-            @_#{column} ||= Spontaneous::Schema::UID[@values[:#{column}]]
+            @_#{column} ||= Spontaneous.schema.uids[@values[:#{column}]]
           end
 
           def #{column}=(sid)
-            @_#{column} = Spontaneous::Schema::UID[sid]
+            @_#{column} = Spontaneous.schema.uids[sid]
             @values[:#{column}] = @_#{column}.to_s
             @_#{column}
           end
-        RUBY
-      end
+      RUBY
+    end
 
-      def schema_id
-        self.class.schema_id
-      end
+    def schema_id
+      self.class.schema_id
+    end
 
-      def schema_name
-        self.class.schema_name
-      end
+    def schema_name
+      self.class.schema_name
+    end
 
-      def schema_owner
-        self.class.schema_owner
-      end
+    def schema_owner
+      self.class.schema_owner
+    end
 
-      def owner_sid
-        self.class.owner_sid
-      end
-    end # InstanceMethods
+    def owner_sid
+      self.class.owner_sid
+    end
   end # SchemaId
 end
-
-
-