spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/plugins/entry.rb

@@ -2,50 +2,65 @@
 
 module Spontaneous::Plugins
   module Entry
-    module InstanceMethods
+    extend ActiveSupport::Concern
 
-      # kept to allow access to pages & pieces as they would be seen when
-      # accessed as an entry in a box
-      def entry
-        self
-      end
+    # InstanceMethods
 
-      def box_sid
-        @box_sid ||= Spot::Schema::UID[self[:box_sid]]
-      end
+    # kept to allow access to pages & pieces as they would be seen when
+    # accessed as an entry in a box
+    def entry
+      self
+    end
 
-      def box_sid=(sid)
-        self[:box_sid] = sid.to_s
-      end
+    def box_sid
+      @box_sid ||= Spontaneous.schema.uids[self[:box_sid]]
+    end
 
-      def box
-        container.boxes.sid(box_sid) if container
-      end
+    def box_sid=(sid)
+      self[:box_sid] = sid.to_s
+    end
 
-      def first?
-        container.pieces.first == self
-      end
+    def box
+      owner.boxes.sid(box_sid) if owner
+    end
 
-      def last?
-        container.pieces.last == self
-      end
+    alias_method :container,  :box
 
-      def set_position(new_position)
-        if box
-          box.set_position(self, new_position)
-        else
-          container.pieces.set_position(self, new_position)
-        end
-      end
+    def first?
+      container.contents.first == self
+    end
 
-      def position
-        container.pieces.index(self)
-      end
+    def last?
+      container.contents.last == self
+    end
+
+    def next
+      return nil if last?
+      container.contents[position + 1]
+    end
+
+    def previous
+      return nil if first?
+      container.contents[position - 1]
+    end
+
+    alias_method :prev, :previous
 
-      def serialize_db
-        [self.id]
+    def set_position(new_position)
+      if box
+        box.set_position(self, new_position)
+      else
+        owner.pieces.set_position(self, new_position)
       end
-    end # InstanceMethods
+    end
+
+    def position
+      return box.index(self) if box
+      owner.pieces.index(self)
+    end
+
+    def serialize_db
+      [self.id]
+    end
   end # Entry
 end # Spontaneous::Plugins
-

data/lib/spontaneous/plugins/field/editor_class.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Field
+  module EditorClass
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def editor_class
+        ui_class
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/fields.rb

@@ -2,14 +2,23 @@
 
 module Spontaneous::Plugins
   module Fields
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def field(name, type=nil, options={}, &block)
         if type.is_a?(Hash)
           options = type
           type = nil
         end
+        prototype = nil
+        name = name.to_sym
+
+        if (existing_prototype = field_prototypes[name])
+          prototype = existing_prototype.merge(self, type, options, &block)
+        else
+          prototype = Spontaneous::Prototypes::FieldPrototype.new(self, name, type, options, &block)
+        end
 
-        prototype = Spontaneous::Prototypes::FieldPrototype.new(self, name, type, options, &block)
         field_prototypes[name] = prototype
         unless method_defined?(name)
           define_method(name) do |*args|
@@ -57,47 +66,46 @@ module Spontaneous::Plugins
       def readable_fields
         field_prototypes.keys.select { |name| field_readable?(name) }
       end
-    end
+    end # ClassMethods
 
-    module InstanceMethods
-      def after_save
-        super
-        fields.saved
-      end
+    # InstanceMethods
 
-      def reload
-        @field_set = nil
-        super
-      end
+    def after_save
+      super
+      fields.saved
+    end
 
-      def field_prototypes
-        self.class.field_prototypes
-      end
+    def reload
+      @field_set = nil
+      super
+    end
 
-      def fields
-        @field_set ||= Spontaneous::Collections::FieldSet.new(self, field_store)
-      end
+    def field_prototypes
+      self.class.field_prototypes
+    end
 
-      def field?(field_name)
-        self.class.field?(field_name)
-      end
+    def fields
+      @field_set ||= Spontaneous::Collections::FieldSet.new(self, field_store)
+    end
 
-      # TODO: unify the update mechanism for these two stores
-      def field_modified!(modified_field)
-        self.field_store = @field_set.serialize_db
-      end
+    def field?(field_name)
+      self.class.field?(field_name)
+    end
 
-      def type_for_mime_type(mime_type)
-        self.class.allowed_types.find do |t|
-          t.field_for_mime_type(mime_type)
-        end
-      end
+    # TODO: unify the update mechanism for these two stores
+    def field_modified!(modified_field)
+      self.field_store = @field_set.serialize_db
+    end
 
-      def field_for_mime_type(mime_type)
-        prototype = self.class.field_for_mime_type(mime_type)
-        self.fields[prototype.name]
+    def type_for_mime_type(mime_type)
+      self.class.allowed_types.find do |t|
+        t.field_for_mime_type(mime_type)
       end
     end
+
+    def field_for_mime_type(mime_type)
+      prototype = self.class.field_for_mime_type(mime_type)
+      self.fields[prototype.name]
+    end
   end
 end
-

data/lib/spontaneous/plugins/instance_code.rb

@@ -2,17 +2,17 @@
 
 module Spontaneous::Plugins
   module InstanceCode
+    extend ActiveSupport::Concern
 
-    module InstanceMethods
-      def after_initialize
-        super
-        mixin_instance_code
-      end
+    # InstanceMethods
 
-      def mixin_instance_code
-        self.instance_eval(self.instance_code) unless self.instance_code.nil?
-      end
+    def after_initialize
+      super
+      mixin_instance_code
+    end
+
+    def mixin_instance_code
+      self.instance_eval(self.instance_code) unless self.instance_code.nil?
     end
   end
 end
-

data/lib/spontaneous/plugins/layouts.rb

@@ -2,6 +2,8 @@
 
 module Spontaneous::Plugins
   module Layouts
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def layout(name, options={})
         layout_prototypes[name] = Spontaneous::Prototypes::LayoutPrototype.new(self, name, options)
@@ -22,7 +24,7 @@ module Spontaneous::Plugins
       end
 
       def default_layout
-        if prototype = (layouts.detect { |prototype| prototype.default? } || layouts.first)
+        if prototype = (layouts.hierarchy_detect { |prototype| prototype.default? } || layouts.local_first)
           prototype.layout(self)
         else
           Spontaneous::Layout::Default.new(self)
@@ -40,48 +42,42 @@ module Spontaneous::Plugins
       end
     end # ClassMethods
 
-    module InstanceMethods
-      def layout
-        resolve_layout(self.style_sid)
-      end
+    # InstanceMethods
 
-      def resolve_layout(style_sid)
-        self.class.resolve_layout(style_sid)
-      end
+    def layout
+      resolve_layout(self.style_sid)
+    end
 
-      def layout=(layout)
-        self.style_sid = layout_to_schema_id(layout)
-      end
+    def resolve_layout(style_sid)
+      self.class.resolve_layout(style_sid)
+    end
+
+    def layout=(layout)
+      self.style_sid = layout_to_schema_id(layout)
+    end
 
-      def layout_to_schema_id(layout)
-        sid = nil
-        if layout.respond_to?(:schema_id)
-          sid = layout.schema_id
+    def layout_to_schema_id(layout)
+      sid = nil
+      if layout.respond_to?(:schema_id)
+        sid = layout.schema_id
+      else
+        if Spontaneous::Schema::UID === layout
+          sid = layout
         else
-          if Spontaneous::Schema::UID === layout
-            sid = layout
-          else
-            if s = self.find_named_layout(layout)
-              sid = s.schema_id
-            end
+          if s = self.find_named_layout(layout)
+            sid = s.schema_id
           end
         end
-        sid
       end
+      sid
+    end
 
-      def find_named_layout(layout_name)
-        self.class.find_named_layout(layout_name)
-      end
+    def find_named_layout(layout_name)
+      self.class.find_named_layout(layout_name)
+    end
 
-      def template(format = :html)
-        layout.template(format)
-      end
-
-      # def provides_format?(format)
-      #   format = (format || :html).to_sym
-      #   self.formats.include?(format)
-      # end
-    end # InstanceMethods
+    def template(format = :html)
+      layout.template(format)
+    end
   end # Layouts
 end # Spontaneous::Plugins
-

data/lib/spontaneous/plugins/media.rb

@@ -2,40 +2,39 @@
 
 module Spontaneous::Plugins
   module Media
-    module ClassMethods
+    extend ActiveSupport::Concern
+
+    # InstanceMethods
+
+    def media_filepath(*args)
+      File.join(Spontaneous.media_dir, padded_id, padded_revision, *args)
+    end
+
+    def media_urlpath(*args)
+      File.join("/media", padded_id, padded_revision, *args)
+    end
+
+    def padded_id
+      save if media_id.nil?
+      media_id.to_s.rjust(5, "0")
     end
 
-    module InstanceMethods
-      def media_filepath(*args)
-        File.join(Spontaneous.media_dir, padded_id, padded_revision, *args)
-      end
-
-      def media_urlpath(*args)
-        File.join("/media", padded_id, padded_revision, *args)
-      end
-
-      def padded_id
-        save if media_id.nil?
-        media_id.to_s.rjust(5, "0")
-      end
-
-      def media_id
-        id
-      end
-
-      def padded_revision
-        Spontaneous::Site.working_revision.to_s.rjust(4, "0")
-      end
-
-      def make_media_file(src_file, filename = nil)
-        filename ||= File.basename(src_file)
-        filename = Spontaneous::Media.to_filename(filename)
-        media_filepath = media_filepath(filename)
-        FileUtils.mkdir_p(File.dirname(media_filepath))
-        FileUtils.cp(src_file, media_filepath)
-        media_filepath
-      end
+    def media_id
+      id
+    end
+
+    def padded_revision
+      Spontaneous::Site.working_revision.to_s.rjust(4, "0")
+    end
+
+    # TODO: Is this still used? It shouldn't be
+    def make_media_file(src_file, filename = nil)
+      filename ||= File.basename(src_file)
+      filename = Spontaneous::Media.to_filename(filename)
+      media_filepath = media_filepath(filename)
+      FileUtils.mkdir_p(File.dirname(media_filepath))
+      FileUtils.cp(src_file, media_filepath)
+      media_filepath
     end
   end
 end
-

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

@@ -1,30 +1,58 @@
 # encoding: UTF-8
 
+require 'rack'
 
 module Spontaneous::Plugins::Page
   module Formats
+    extend ActiveSupport::Concern
+
     module ClassMethods
       def formats(*formats)
-        @formats ||= [:html]
-        return @formats if formats.nil? or formats.empty?
+        return format_list if formats.nil? or formats.empty?
         set_formats(formats)
       end
 
+      def format_list
+        @formats ||= supertype_formats
+      end
+
+      def mime_types
+        @mime_types ||= supertype_mimetypes
+      end
+
+      def add_format(new_format)
+        format = define_format(new_format)
+        format_list.push(format)
+      end
+
       def set_formats(formats)
-        @mime_types = {}
         formats = formats.flatten
+        mime_types.clear
+        format_list.clear
+        formats.map do |format|
+          format_list.push define_format(format)
+        end
+      end
+
+      def define_format(format)
         mime_type = nil
-        @formats = formats.map do |format|
-          if format.is_a?(Hash)
-            mime_type = format.values.first
-            format = format.keys.first
-            @mime_types[format.to_sym] = mime_type
-          else
-            mime_type = ::Rack::Mime.mime_type("#{Spontaneous::DOT}#{format}", nil)
-          end
-          raise Spontaneous::UnknownFormatException.new(format) unless mime_type
-          format.to_sym
+        if format.is_a?(Hash)
+          mime_type = format.values.first
+          format = format.keys.first
+          mime_types[format.to_sym] = mime_type
+        else
+          mime_type = ::Rack::Mime.mime_type(".#{format}", nil)
         end
+        raise Spontaneous::UnknownFormatException.new(format) unless mime_type
+        format.to_sym
+      end
+
+      def supertype_formats
+        supertype? && supertype.respond_to?(:formats) ? supertype.formats.dup : [:html]
+      end
+
+      def supertype_mimetypes
+        supertype? && supertype.respond_to?(:mime_types) ? supertype.mime_types.dup : {}
       end
 
       def default_format
@@ -37,31 +65,28 @@ module Spontaneous::Plugins::Page
       end
 
       def mime_type(format)
-        if @mime_types && @mime_types.key?(format)
-          @mime_types[format]
+        if mime_types && mime_types.key?(format)
+          mime_types[format]
         else
-          ::Rack::Mime.mime_type("#{Spontaneous::DOT}#{format}")
+          ::Rack::Mime.mime_type(".#{format}")
         end
       end
-    end
+    end # ClassMethods
 
-    module InstanceMethods
-      def formats
-        self.class.formats
-      end
+    def formats
+      self.class.formats
+    end
 
-      def default_format
-        self.class.default_format
-      end
+    def default_format
+      self.class.default_format
+    end
 
-      def provides_format?(format)
-        self.class.provides_format?(format)
-      end
+    def provides_format?(format)
+      self.class.provides_format?(format)
+    end
 
-      def mime_type(format)
-        self.class.mime_type(format)
-      end
+    def mime_type(format)
+      self.class.mime_type(format)
     end
   end # Formats
 end # Spontaneous::Plugins::Page
-