spontaneous 0.2.0.beta5 → 0.2.0.beta6

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

@@ -22,7 +22,7 @@ module Spontaneous::Media::Image
 
     def run
       format = Spontaneous::Media::Image.format(@image)
-      if respond_to?(format)
+      if format && respond_to?(format)
         send(format)
       end
     end

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

@@ -7,11 +7,20 @@ module Spontaneous::Media::Image
     end
 
     def apply(process)
-      cmd = convert(@input, :to => @output, &process)
-      cmd.run
+      if imagemagick_installed?
+        cmd = convert(@input, :to => @output, &process)
+        cmd.run
+      else
+        logger.warn("Unable to re-size image, Imagemagick is not installed.")
+        FileUtils::Verbose.cp(@input, @output)
+      end
     end
 
     def optimize!
     end
+
+    def imagemagick_installed?
+      Kernel.system('which convert >/dev/null 2>&1')
+    end
   end
 end

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

@@ -12,6 +12,8 @@ module Spontaneous::Media::Image
       end
     end
 
+    alias_method :render_inline, :render
+
     def to_html(attr={})
       default_attr = {
         :src => src,

data/lib/spontaneous/model.rb

@@ -1,6 +1,9 @@
+
 module Spontaneous
 
   module Model
+    ANCESTOR_SEP = "."
+
     autoload :Core,   "spontaneous/model/core"
     autoload :Page,   "spontaneous/model/page"
     autoload :Piece,  "spontaneous/model/piece"

data/lib/spontaneous/model/box/allowed_types.rb

@@ -5,6 +5,8 @@ module Spontaneous::Model::Box
     extend Spontaneous::Concern
 
     class AllowedType
+      prepend Spontaneous::Model::Page::Singleton::AllowedTypeMethods
+
       attr_accessor :allow_subclasses
 
       def initialize(box, type, options={}, &definition)
@@ -81,6 +83,10 @@ module Spontaneous::Model::Box
       end
 
       def instance_classes
+        unfiltered_instance_classes.reject {|type| exclude_type?(type) }
+      end
+
+      def unfiltered_instance_classes
         if allow_subclasses
           instance_class.subclasses
         else
@@ -88,14 +94,20 @@ module Spontaneous::Model::Box
         end
       end
 
+      def exclude_type?(type)
+        false
+      end
+
       def export
         if allow_subclasses
           # can't configure interface name using allow_subclasses
           instance_class.subclasses.map { |c| { type: c.ui_class } }
         else
-          exported = {type: instance_class.ui_class }
-          exported[:as] = @options[:as] if @options.key?(:as)
-          [exported]
+          instance_classes.map {|instance_class|
+            exported = {type: instance_class.ui_class }
+            exported[:as] = @options[:as] if @options.key?(:as)
+            exported
+          }
         end
       end
 
@@ -127,6 +139,7 @@ module Spontaneous::Model::Box
           name.to_s.constantize
         end
       end
+
     end
 
     class AllowedGroup < AllowedType
@@ -134,7 +147,7 @@ module Spontaneous::Model::Box
         @type
       end
 
-      def instance_classes
+      def unfiltered_instance_classes
         names = groups.flat_map { |name| schema.groups[name] }
         names.map { |name| resolve_instance_class(name) }.uniq
       end

data/lib/spontaneous/model/core.rb

@@ -5,6 +5,7 @@ module Spontaneous::Model
     autoload :Aliases,          "spontaneous/model/core/aliases"
     autoload :Boxes,            "spontaneous/model/core/boxes"
     autoload :ContentGroups,    "spontaneous/model/core/content_groups"
+    autoload :ContentHash,      "spontaneous/model/core/content_hash"
     autoload :EditorClass,      "spontaneous/model/core/editor_class"
     autoload :Entries,          "spontaneous/model/core/entries"
     autoload :Entry,            "spontaneous/model/core/entry"
@@ -25,10 +26,13 @@ module Spontaneous::Model
     autoload :Styles,           "spontaneous/model/core/styles"
     autoload :Supertype,        "spontaneous/model/core/supertype"
     autoload :Visibility,       "spontaneous/model/core/visibility"
+    autoload :CascadingChange,  "spontaneous/model/core/cascading_change"
 
     extend Spontaneous::Concern
 
     module ClassMethods
+      include Spontaneous::Model::Page::Singleton::ContentClassMethods
+
       def page?
         false
       end
@@ -46,10 +50,12 @@ module Spontaneous::Model
         !supertype.nil?
       end
 
-      def root
+      def public_root
         content_model::Page.root
       end
 
+      alias_method :root, :public_root
+
       def log_sql(io = $stdout)
         mapper.logger = ::Logger.new(io)
         yield if block_given?
@@ -70,6 +76,7 @@ module Spontaneous::Model
 
     include Enumerable
 
+    include CascadingChange
     include SchemaId
     include Entry
     include Boxes
@@ -88,6 +95,7 @@ module Spontaneous::Model
     include Prototypes
     include Permissions
     include ContentGroups
+    include ContentHash
     include SchemaHierarchy
     include PageSearch
     include Locks
@@ -101,8 +109,19 @@ module Spontaneous::Model
       false
     end
 
-    def root
-      content_model::Page.root
+    # Provide a default implementation of this that is later over-ridden by the page methods
+    def is_public_root?
+      false
+    end
+
+    def public_root
+      is_public_root? ? self : content_model::Page.root
+    end
+
+    alias_method :root, :public_root
+
+    def visibility_path_ids
+      (self[:visibility_path] || "").split(ANCESTOR_SEP).map { |id| id.to_i }
     end
 
     def content_instance
@@ -116,12 +135,26 @@ module Spontaneous::Model
       self
     end
 
+    # Returns a version of this object as a page.
+    # This is used by the rendering system to guarantee that the object
+    # it is recieving is a page & not a PagePiece proxy. See PagePiece#to_page
+    def to_page
+      page
+    end
+
     def page?
       false
     end
 
     alias_method :is_page?, :page?
 
+    # Do not overwrite this method directly.
+    # If you want a page to render the content of another configure
+    # the type using Content::render
+    def renderable
+      self
+    end
+
     def start_inline_edit_marker
       "spontaneous:previewedit:start:content id:#{id}"
     end

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

@@ -120,6 +120,10 @@ module Spontaneous::Model::Core
         __target
       end
 
+      def fields
+        @field_set ||= Spontaneous::Collections::FieldSet.new(self, field_store, target, :fields)
+      end
+
       def field?(field_name)
         super || target.class.field?(field_name)
       end
@@ -146,7 +150,6 @@ module Spontaneous::Model::Core
         end
       end
 
-
       def find_named_style(style_name)
         super or target.find_named_style(style_name)
       end
@@ -161,7 +164,7 @@ module Spontaneous::Model::Core
         @styles ||= Spontaneous::Collections::PrototypeSet.new(target, :styles)
       end
 
-      def export(user = nil)
+      def shallow_export(user = nil)
         super.merge(:target => exported_target(user), :alias_title => target.alias_title, :alias_icon => target.exported_alias_icon)
       end
 

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

@@ -78,6 +78,12 @@ module Spontaneous::Model::Core
       @boxes ||= Spontaneous::Collections::BoxSet.new(self)
     end
 
+    # Used by #content_hash to attempt to preserve content hashes across
+    # schema changes
+    def boxes_with_consistent_order
+      boxes.sort { |b1, b2| b1.schema_id <=> b2.schema_id }
+    end
+
     def pieces
       boxes.flat_map { |b| b.pieces }
     end

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

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Spontaneous::Model::Core
+  module CascadingChange
+    extend Spontaneous::Concern
+
+    module ClassMethods
+      def cascading_change(attr_name, &block)
+        define_method "#{attr_name}=" do |value|
+          append_cascading_change(attr_name, self[attr_name], value, &block)
+          super(value)
+        end
+      end
+    end
+
+    private
+
+    def changes_to_cascade
+      @changes_to_cascade ||= {}
+    end
+
+    def append_cascading_change(attribute, old_value, new_value, &block)
+      changes_to_cascade[attribute] = block.call(self, old_value, new_value) if new_value != old_value
+    end
+
+    def after_save
+      super
+      cascade_all_changes
+    end
+
+    def cascade_all_changes
+      changes_to_cascade.each do |attribute, propagator|
+        propagator.propagate
+      end
+      changes_to_cascade.clear
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# encoding: UTF-8
+
+require 'digest/md5'
+
+module Spontaneous::Model::Core
+  module ContentHash
+    extend Spontaneous::Concern
+
+    def self.calculate(*values)
+      values = Array(values).flatten
+      md5 = Digest::MD5.new
+      values.each do |value|
+        md5.update(value.to_s)
+      end
+      md5.hexdigest
+    end
+
+    class ContentHashChange
+      def initialize(origin)
+        @origin = origin
+      end
+
+      def propagate
+        content = owner
+        while propagate_to?(content)# && content.modification_tracking_enabled?
+          content.recalculate_content_hash!# if propagate_to_owner?
+          break if content == @origin.page
+          content = content.owner
+        end
+      end
+
+      def propagate_to?(content)
+        !(content.nil? || (@origin.page? && content.page?)) && content.modification_tracking_enabled?
+      end
+
+      def owner
+        @origin.owner
+      end
+    end
+
+    included do
+      cascading_change :content_hash do |origin, old_value, new_value|
+        ContentHashChange.new(origin)
+      end
+    end
+
+    def content_hash_changed?
+      content_hash_changed
+    end
+
+    def content_hash
+      super || calculate_content_hash
+    end
+
+    def calculate_content_hash
+      Spontaneous::Model::Core::ContentHash.calculate(content_hash_dependencies { |el| el.content_hash })
+    end
+
+    def calculate_content_hash!
+      Spontaneous::Model::Core::ContentHash.calculate(content_hash_dependencies { |el| el.calculate_content_hash! })
+    end
+
+    def content_hash_dependencies(&calculation)
+      fields = fields_with_consistent_order.map(&calculation)
+      boxes = boxes_with_consistent_order.reject(&:generated?).map(&calculation)
+      content_hash_columns.concat(fields).concat(boxes)
+    end
+
+    def content_hash_columns
+      [schema_id, hidden?, target_id]
+    end
+
+    def before_save
+      # Only recalculate the content hash if we're in the editable dataset, otherwise
+      # the published data can end up with a different content hash even after being published
+      recalculate_content_hash if modification_tracking_enabled?
+      enable_modification_tracking
+      super
+      true
+    end
+
+    def recalculate_content_hash
+      attrs, changed = content_hash_attributes
+      set(attrs) if changed
+    end
+
+    # Update the instances content hash by writing direct to the db & without triggering any futher cascading changes
+    # Without the #reload call existing cached versions of the
+    # content tree may be used and changes will not propagate
+    def recalculate_content_hash!
+      reload unless modified?
+      attrs, changed = content_hash_attributes
+      model.where(id: id).update(attrs) if changed
+    end
+
+    def content_hash_attributes
+      db, current, published = self[:content_hash], calculate_content_hash, published_content_hash
+      changed = published.blank? || current != published
+      [{content_hash: current, content_hash_changed: changed, content_hash_changed_at: ::Sequel.datetime_class.now}, db != current]
+    end
+
+    def modification_tracking_enabled?
+      mapper.editable? && !@modification_tracking_disabled
+    end
+
+    def disable_modification_tracking!
+      @modification_tracking_disabled = true
+    end
+
+    def enable_modification_tracking
+      @modification_tracking_disabled = false
+    end
+
+    def insert_page(index, child_page, box)
+      page.disable_modification_tracking! unless page.nil?
+      super
+    end
+
+    module PageMethods
+      # Make page modification state depend on its path
+      def content_hash_dependencies
+        super.push(slug)
+      end
+    end
+
+    module BoxMethods
+      def generated?
+        _prototype.generated?
+      end
+
+      def content_hash
+        _content_hash { |el| el.content_hash }
+      end
+
+      # boxes have no persisted value for their content hash
+      alias_method :calculate_content_hash, :content_hash
+
+      def calculate_content_hash!
+        _content_hash { |el| el.calculate_content_hash! }
+      end
+
+      def _content_hash(&calculation)
+        return "" if fields.empty? && empty?
+        fields = fields_with_consistent_order.map(&calculation)
+        entry_hashes = map(&calculation)
+        Spontaneous::Model::Core::ContentHash.calculate(fields, entry_hashes)
+      end
+    end
+
+    module FieldMethods
+      def content_hash
+        Spontaneous::Model::Core::ContentHash.calculate(unprocessed_value)
+      end
+
+      alias_method :calculate_content_hash,  :content_hash
+      alias_method :calculate_content_hash!, :content_hash
+    end
+
+    module PagePieceMethods
+      # Because pages all publish independently we don't want the content hash
+      # of boxes to change if a contained page is modified, so make the hash
+      # of pages inside boxes only depend on the id (so the box hash does change
+      # when the page is added, moved or deleted)
+      def content_hash
+        Spontaneous::Model::Core::ContentHash.calculate(id)
+      end
+      alias_method :calculate_content_hash,  :content_hash
+      alias_method :calculate_content_hash!, :content_hash
+    end
+  end
+end