spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/media/image/skeptick.rb

@@ -0,0 +1,70 @@
+require 'skeptick'
+
+module Skeptick
+  module Sugar
+    module Fitting
+      def width(width, options = {})
+        options = make_options(options, :width => width)
+        set :resize, geometry(options)
+      end
+
+      def height(height, options = {})
+        options = make_options(options, :height => height)
+        set :resize, geometry(options)
+      end
+
+      # Implements #resize_to_fit
+      def fit(options = {})
+        options = make_options(options)
+        set :resize, geometry(options)
+      end
+
+      # Implements #resize_to_fill
+      def fill(options = {})
+        gravity = options.delete(:gravity) || "Center"
+        defaults = {
+          :left  => 0,
+          :top   => 0,
+          :exact => true
+        }
+        options = make_options(options, defaults)
+
+        size = options.select { |k, v| [:width, :height, :shrink_only].include?(k) }
+
+        set :geometry, "#{geometry(size)}^"
+        set :gravity,  gravity
+        set :crop,     geometry(options)
+      end
+
+      alias_method :crop, :fill
+
+      def greyscale
+        set :type, "Grayscale"
+      end
+
+      alias_method :grayscale, :greyscale
+
+      # def rounded(radius)
+      #     rounded_corners_image(self, :radius => radius)
+      # end
+
+      def make_options(options, defaults = {})
+        enlarge = options.delete(:enlarge) || false
+        defaults.merge(:shrink_only => !enlarge).merge(options)
+      end
+    end
+  end
+
+  include Sugar::Fitting
+
+  class   Image::DslContext; include Sugar::Fitting end
+  class Convert::DslContext; include Sugar::Fitting end
+end
+
+module Spontaneous::Media
+  module Image
+    module Skeptick
+      include ::Skeptick
+    end
+  end
+end

data/lib/spontaneous/media/image.rb

@@ -0,0 +1,50 @@
+module Spontaneous::Media
+  module Image
+    autoload :Attributes, "spontaneous/media/image/attributes"
+    autoload :Format,     "spontaneous/media/image/format"
+    autoload :Optimizer,  "spontaneous/media/image/optimizer"
+    autoload :Processor,  "spontaneous/media/image/processor"
+    autoload :Renderable, "spontaneous/media/image/renderable"
+    autoload :Skeptick,   "spontaneous/media/image/skeptick"
+
+    def self.dimensions(file)
+      new(file).dimensions
+    end
+
+    def self.type(file)
+      new(file).format
+    end
+
+    def self.format(file)
+      new(file).format
+    end
+
+    def self.identify(file)
+      new(file)
+    end
+
+    def self.header_size
+      formats.map { |magic, _| magic.length }.max
+    end
+
+    def self.peek(file)
+      file.read(header_size).unpack("C*")
+    end
+
+    def self.formats
+      @formats ||= {}
+    end
+
+    def self.define(ext, magic, &block)
+      formats[ext] = [magic, block]
+    end
+
+    def self.new(file)
+      Format.new(file)
+    end
+  end
+end
+
+Dir[::File.dirname(__FILE__) + "/image/format/*.rb"].each do |format|
+  require format
+end

data/lib/spontaneous/media/temp_file.rb

@@ -19,5 +19,9 @@ module Spontaneous::Media
     def storage_path
       ["tmp", padded_id, filename]
     end
+
+    def padded_id
+      Spontaneous::Media.pad_id(owner.media_id)
+    end
   end
 end

data/lib/spontaneous/media.rb

@@ -6,6 +6,7 @@ module Spontaneous
   module Media
 
     autoload :File,     "spontaneous/media/file"
+    autoload :Image,    "spontaneous/media/image"
     autoload :TempFile, "spontaneous/media/temp_file"
 
     include Spontaneous::Constants

data/lib/spontaneous/model/core/aliases.rb

@@ -151,13 +151,10 @@ module Spontaneous::Model::Core
         super or target.find_named_style(style_name)
       end
 
+      # Aliases are unique in that their style depends on the instance as well
+      # as the class.
       def style
-        return self.resolve_style(self.style_sid) unless target.respond_to?(:resolve_style)
-        if self.class.styles.empty?
-          target.resolve_style(style_sid)
-        else
-          self.resolve_style(self.style_sid) or target.resolve_style(self.style_sid)
-        end
+        Spontaneous::Style::AliasStyle.new(self)
       end
 
       def styles
@@ -213,12 +210,21 @@ module Spontaneous::Model::Core
 
     # InstanceMethods
 
+    # Used as the title for this instance in the list of potential targets for
+    # and alias.
     def alias_title
-      fields[:title].to_s
+      alias_title_field.to_s
+    end
+
+    def alias_title_field
+      unless (field = fields[:title])
+        field = fields.detect { |f| f.is_a?(Spontaneous::Field::String) }
+      end
+      field
     end
 
     def alias_icon_field
-      if field = fields.detect { |f| f.image? }
+      if (field = fields.detect { |f| f.image? })
         field
       else
         nil

data/lib/spontaneous/model/core/boxes.rb

@@ -10,6 +10,9 @@ module Spontaneous::Model::Core
         prototype = nil
         options[:group] = @box_group if @box_group
 
+        # Because of load conflicts types are likely to be loaded twice
+        return if box?(name, false)
+
         if existing_prototype = boxes[name]
           prototype = existing_prototype.merge(self, options, &block)
         else
@@ -44,8 +47,8 @@ module Spontaneous::Model::Core
         box_prototypes.order = new_order.flatten
       end
 
-      def box?(box_name)
-        box_prototypes.key?(box_name.to_sym)
+      def box?(box_name, inherited = true)
+        box_prototypes.key?(box_name.to_sym, inherited)
       end
 
       def is_box?

data/lib/spontaneous/model/core/entries.rb

@@ -151,6 +151,7 @@ module Spontaneous::Model::Core
       content.box_sid = box.schema_id if box
       content._prototype = box.prototype_for_content(content) if box
       content.set_visible(self.visible?, self.id)
+      content.after_insertion
       content.save if content.new?
       entry = \
         case type
@@ -171,6 +172,9 @@ module Spontaneous::Model::Core
       entry
     end
 
+    def after_insertion
+    end
+
     # added is my private mechanism for tracking if a content item is new
     def before_create
       @added = true

data/lib/spontaneous/model/core/entry.rb

@@ -56,6 +56,7 @@ module Spontaneous::Model::Core
 
     def position
       return box.index(self) if box
+      return 0 if owner.nil? # special case for root
       owner.pieces.index(self)
     end
 

data/lib/spontaneous/model/core/fields.rb

@@ -13,6 +13,9 @@ module Spontaneous::Model::Core
         prototype = nil
         name = name.to_sym
 
+        # Because of load conflicts types are likely to be loaded twice
+        return self.fields[name] if self.field?(name, false)
+
         if (existing_prototype = field_prototypes[name])
           prototype = existing_prototype.merge(self, type, options, &block)
         else
@@ -53,8 +56,8 @@ module Spontaneous::Model::Core
         field_prototypes.order = new_order.flatten if new_order and !new_order.empty?
       end
 
-      def field?(field_name)
-        field_prototypes.key?(field_name)
+      def field?(field_name, inherited = true)
+        field_prototypes.key?(field_name, inherited)
       end
 
       def field_for_mime_type(mime_type)

data/lib/spontaneous/model/core/locks.rb

@@ -0,0 +1,16 @@
+module Spontaneous::Model::Core
+  # Ensure that any page locks belonging to content items are destroyed along
+  # with the content.
+  #
+  # This has to be separate from any page-level deletion because the locks are
+  # owned by both and deleting the contents of a box should release locks
+  # belonging to them.
+  module Locks
+    extend Spontaneous::Concern
+
+    def after_destroy
+      Spontaneous::PageLock.where(:content_id => id).delete
+      super
+    end
+  end
+end

data/lib/spontaneous/model/core/media.rb

@@ -4,27 +4,13 @@ module Spontaneous::Model::Core
   module Media
     extend Spontaneous::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")
+      Spontaneous::Media.pad_id(media_id)
     end
 
     def media_id
       id
     end
-
-    def padded_revision
-      Spontaneous::Site.working_revision.to_s.rjust(4, "0")
-    end
   end
 end

data/lib/spontaneous/model/core.rb

@@ -10,6 +10,7 @@ module Spontaneous::Model
     autoload :Entry,            "spontaneous/model/core/entry"
     autoload :Fields,           "spontaneous/model/core/fields"
     autoload :InstanceCode,     "spontaneous/model/core/instance_code"
+    autoload :Locks,            "spontaneous/model/core/locks"
     autoload :Media,            "spontaneous/model/core/media"
     autoload :Modifications,    "spontaneous/model/core/modifications"
     autoload :PageSearch,       "spontaneous/model/core/page_search"
@@ -79,6 +80,7 @@ module Spontaneous::Model
     include ContentGroups
     include SchemaHierarchy
     include PageSearch
+    include Locks
 
     # marker method enabling a simple test for "cms content" vs "everything else"
     def spontaneous_content?
@@ -119,7 +121,35 @@ module Spontaneous::Model
     end
 
     def to_s
-      %(#<#{self.class.name} id=#{id}>)
+      inspect
+    end
+
+    def inspect
+      values = inspection_values.map { |(name, value)| "#{name}=#{value.inspect}" }.join(" ")
+      %(#<#{self.class.name} #{values}>)
+    end
+
+    def inspection_values
+
+      location = if container.nil?
+                   [path]
+                 elsif page
+                   [page.path, container._name, position].compact
+                 elsif container
+                   [container._name, position]
+                 else
+                   []
+                 end
+      { :id => id, :location => location.join(":") }.merge(inspection_fields)
+    end
+
+    def inspection_fields
+      crop = lambda{ |str|
+        len = 23
+        return str if str.length <= len
+        str[0...len] + "…"
+      }
+      Hash[fields.map { |field| [field.name, crop[field.unprocessed_value]]}]
     end
 
     def each

data/lib/spontaneous/model/page/controllers.rb

@@ -45,8 +45,8 @@ module Spontaneous::Model::Page
 
     # 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{//}, '/')
+    def action_url(namespace, path = nil)
+      [self.path, "#{ACTION_SEPARATOR}#{namespace}", path].compact.join(S::Constants::SLASH).gsub(%r{//}, '/')
     end
   end # Controllers
 end

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

@@ -106,10 +106,7 @@ module Spontaneous::Model::Page
     end
 
     def render(format=:html, params={}, *args)
-      if format.is_a?(Hash)
-        params = format
-        format = :html
-      end
+      params, format = format, :html if format.is_a?(Hash)
       output = output(format)
       output.render(params, *args)
     end

data/lib/spontaneous/model/page/layouts.rb

@@ -7,13 +7,17 @@ module Spontaneous::Model::Page
     module ClassMethods
       def layout(name = nil, options = {}, &block)
         if block_given?
-          @layout_proc = block
+          layout_procs[name] = block
         else
           raise "Layouts must be given a name" if name.blank?
           layout_prototypes[name] = Spontaneous::Prototypes::LayoutPrototype.new(self, name, options)
         end
       end
 
+      def layout_procs
+        @layout_procs ||= {}
+      end
+
       def layout_prototypes
         @layout_prototypes ||= Spontaneous::Collections::PrototypeSet.new(supertype, :layout_prototypes)
       end
@@ -29,7 +33,7 @@ module Spontaneous::Model::Page
       end
 
       def default_layout
-        return Spontaneous::Layout::Anonymous.new(@layout_proc) unless @layout_proc.nil?
+        return Spontaneous::Layout::Anonymous.new(layout_procs) unless layout_procs.empty?
         if prototype = (layouts.hierarchy_detect { |prototype| prototype.default? } || layouts.local_first)
           prototype.layout(self)
         else

data/lib/spontaneous/model/page/locks.rb

@@ -5,10 +5,16 @@ module Spontaneous::Model::Page
     extend Spontaneous::Concern
 
     included do
-      one_to_many :update_locks, :model => Spontaneous::PageLock, :key => :page_id
+      one_to_many :update_locks, :class => Spontaneous::PageLock, :key => :page_id
     end
+
     def locked_for_update?
       !update_locks.empty?
     end
+
+    def after_destroy
+      update_locks_dataset.delete
+      super
+    end
   end
-end
+end

data/lib/spontaneous/model/page/page_tree.rb

@@ -54,11 +54,11 @@ module Spontaneous::Model::Page
     end
 
     def generation
-      parent ? parent.children : [root]
+      parent ? parent.children : [root].compact
     end
 
     def siblings
-      generation.reject { |p| p === self }
+      generation.reject { |p| p.id == id }
     end
 
     def >(page)

data/lib/spontaneous/model/page/paths.rb

@@ -12,15 +12,29 @@ module Spontaneous::Model::Page
       def is_default_slug?(slug)
         /^page-\d{8}-\d{6}$/ === slug
       end
+
+      def create_root(slug)
+        create(slug: slug, :__create_hidden_root =>  true)
+      end
     end
 
     # InstanceMethods
 
     ANCESTOR_SEP = "."
 
+    def __create_hidden_root=(state)
+      @__is_hidden_root = state
+    end
+
+    def __create_hidden_root?
+      @__is_hidden_root || false
+    end
+
+    private :__create_hidden_root=, :__create_hidden_root?
+
     def after_initialize
       super
-      self.slug = default_slug if slug.nil?
+      set_generated_slug
     end
 
     def before_create
@@ -28,6 +42,26 @@ module Spontaneous::Model::Page
       super
     end
 
+    def after_insertion
+      super
+      fix_generated_slug_conflicts
+    end
+
+    def set_generated_slug
+      return unless slug.nil?
+      self.slug = generate_default_slug
+    end
+
+    def fix_generated_slug_conflicts
+      o = s = slug || generate_default_slug
+      n = 0
+      while is_conflicting_slug?(s)
+        n += 1
+        s = "#{o}-#{n.to_s.rjust(2, "0")}"
+      end
+      self.slug = s
+    end
+
     # Test for title changes and update the slug to match if it hasn't already
     # been set.
     #
@@ -40,6 +74,7 @@ module Spontaneous::Model::Page
           set_slug_from_title(title)
         end
       end
+      fix_generated_slug_conflicts
       super
     end
 
@@ -57,6 +92,10 @@ module Spontaneous::Model::Page
       end
     end
 
+    def sync_slug_to_title
+      self.slug = title.unprocessed_value
+    end
+
     def has_generated_slug?
       self.class.is_default_slug?(slug)
     end
@@ -66,10 +105,14 @@ module Spontaneous::Model::Page
       check_for_path_changes
     end
 
-    def default_slug
+    def generate_default_slug
       self.class.generate_default_slug
     end
 
+    def is_conflicting_slug?(slug)
+      siblings.reject { |s| s.root? }.compact.map(&:slug).include?(slug)
+    end
+
     def parent=(parent)
       @__parent_changed = true
       update_path
@@ -77,8 +120,12 @@ module Spontaneous::Model::Page
     end
 
     def place_in_page_tree
-      if self.parent_id.nil?
-        make_root unless content_model.has_root?
+      if parent_id.nil?
+        if __create_hidden_root? || content_model.has_root?
+          make_hidden_root
+        else
+          make_root
+        end
       else
         update_path
       end
@@ -90,6 +137,12 @@ module Spontaneous::Model::Page
       self[:ancestor_path] = ""
     end
 
+    def make_hidden_root
+      raise Spontaneous::AnonymousRootException.new if slug.blank?
+      self[:path] = "##{slug}"
+      self[:ancestor_path] = ""
+    end
+
     def ancestor_path
       (self[:ancestor_path] || "").split(ANCESTOR_SEP).map { |id| id.to_i }
     end
@@ -115,21 +168,33 @@ module Spontaneous::Model::Page
 
     def calculate_path_with_slug(slug)
       if parent.nil?
-        root? ? Spontaneous::SLASH : '' # bad case, no parent but not root
+        root? ? Spontaneous::SLASH : "##{slug}"
       else
         File.join(parent.path, slug)
       end
     end
 
+    # slugs can be max 64 characters long
     def slug=(s)
-      if (new_slug = s.to_url) != self.slug
-        @__slug_changed = self.slug
-        # slugs can be max 255 characters long
-        self[:slug] = new_slug[0..254]
+      if (new_slug = fit_slug_to_length(s, 64)) != slug
+        @__slug_changed = slug
+        self[:slug] = new_slug
         self.update_path
       end
     end
 
+    def fit_slug_to_length(s, max_length)
+      original = s.to_url
+      parts    = original.split('-')
+      url      = [parts.shift]
+      while !parts.empty? && ((url + [parts[0]]).join('-').length <= max_length)
+        url << parts.shift
+      end
+      url.join('-')[0...max_length]
+    end
+
+    protected :fit_slug_to_length
+
     def check_for_path_changes(force = false)
       if @__slug_changed || force
         @__slug_changed = false

data/lib/spontaneous/model/page.rb

@@ -26,9 +26,9 @@ module Spontaneous::Model
     include Locks
 
     included do
-      many_to_one :parent, :model => self,   :key => :parent_id, :reciprocal => :unordered_children
-      one_to_many :unordered_children, :model => self, :key => :parent_id, :reciprocal => :parent
-      one_to_many :content, :model => self, :key => :page_id,   :reciprocal => :page
+      many_to_one_content :parent,   :key => :parent_id, :reciprocal => :unordered_children
+      one_to_many_content :unordered_children, :key => :parent_id, :reciprocal => :parent
+      one_to_many_content :content, :key => :page_id,   :reciprocal => :page
     end
 
     # field :title, :string, :default => "New Page"
@@ -139,5 +139,13 @@ module Spontaneous::Model
       hash.delete(:name)
       hash
     end
+
+    def serialize_db
+      [target.id, @style_id]
+    end
+
+    def inspecttion_values
+      { :id => id, :uid => uid, :path => path }.merge(inspection_fields)
+    end
   end
 end

data/lib/spontaneous/model.rb

@@ -21,14 +21,14 @@ module Spontaneous
       include_all_types
     end
     model.class_eval do
-      many_to_one :owner,      :key => :owner_id, :model => self, :reciprocal => :_pieces
-      one_to_many :_pieces,    :key => :owner_id, :model => self, :reciprocal => :owner
-      many_to_one :page,       :key => :page_id,  :model => self, :reciprocal => :content
-      many_to_one :created_by, :key => :created_by_id, :model => Spontaneous::Permissions::User
+      many_to_one_content :owner,      :key => :owner_id, :reciprocal => :_pieces
+      one_to_many_content :_pieces,    :key => :owner_id, :reciprocal => :owner
+      many_to_one_content :page,       :key => :page_id, :reciprocal => :content
+      many_to_one :created_by, :key => :created_by_id, :class => Spontaneous::Permissions::User
       # '__target' rather than 'target' because we want to override the behaviour of the
       # Content#target method only on classes that are aliases, and this is defined dynamically
-      many_to_one :__target,   :key => :target_id, :model => self, :reciprocal => :aliases
-      one_to_many :aliases,    :key => :target_id, :model => self, :reciprocal => :__target, :dependent => :destroy
+      many_to_one_content :__target,   :key => :target_id, :reciprocal => :aliases
+      one_to_many_content :aliases,    :key => :target_id, :reciprocal => :__target, :dependent => :destroy
     end
     model.send :extend,  ContentModelClassMethods
     model.send :include, ContentModelInstanceMethods

data/lib/spontaneous/output/context/render_cache.rb

@@ -0,0 +1,23 @@
+module Spontaneous::Output::Context
+  module RenderCache
+    def _render_cache_value(key)
+      _renderer.render_cache[key]
+    end
+
+    def _render_cache_set_value(key, value)
+      _renderer.render_cache[key] = value
+    end
+
+    def _render_cache_key?(key)
+      _renderer.render_cache.key?(key)
+    end
+
+    def _with_render_cache(key, &value_block)
+      if _render_cache_key?(key)
+        _render_cache_value(key)
+      else
+        _render_cache_set_value(key, yield)
+      end
+    end
+  end
+end