spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/{field_types/image_field.rb → field/image.rb}

@@ -4,8 +4,7 @@ require 'tempfile'
 require 'mini_magick'
 require 'delegate'
 
-module Spontaneous
-  module FieldTypes
+module Spontaneous::Field
 
     class ImageOptimizer
       def self.run(source_image)
@@ -63,7 +62,7 @@ module Spontaneous
 
       def render(format=:html, *args)
         case format
-        when :html
+        when "html", :html
           to_html(*args)
         else
           value
@@ -108,8 +107,8 @@ module Spontaneous
       end
     end
 
-    class ImageField < Field
-      include Spontaneous::Plugins::Field::EditorClass
+    class Image < File
+      has_editor
       include ImageFieldUtilities
 
       def self.accepts
@@ -137,7 +136,13 @@ module Spontaneous
       end
 
       def self.size_definitions
-        @size_definitions ||= superclass.respond_to?(:size_definitions) ? superclass.size_definitions.dup : {}
+        @size_definitions ||= superclass.respond_to?(:size_definitions) ? superclass.size_definitions.dup : { :__ui__ => ui_preview_size }
+      end
+
+      def self.ui_preview_size
+        Proc.new {
+          width 300
+        }
       end
 
       def image?
@@ -153,6 +158,16 @@ module Spontaneous
         value
       end
 
+      def serialize_pending_file(file)
+        attrs = ImageProcessor.new(file).serialize
+        attrs.delete(:path)
+        attrs.merge(super)
+      end
+
+      def page_lock_description
+        "Processing image '#{pending_value[:value][:filename]}'"
+      end
+
       # original is special and should always be defined
       def original
         @original ||= sizes[:original]
@@ -180,15 +195,20 @@ module Spontaneous
 
       # formats are irrelevant to image/file fields
       def outputs
-        [:original].concat(self.class.size_definitions.map { |name, process| name })
+        [:original, :__ui__].concat(self.class.size_definitions.map { |name, process| name })
       end
 
       def value(format=:html, *args)
         sizes[:original].src
       end
 
+      def set_value!(value, process = true)
+        @sizes = nil
+        super
+      end
+
       def generate(output, media_file)
-        return { :src => media_file } if media_file.is_a?(String)#File.exist?(image_path)
+        return { :src => media_file } if media_file.is_a?(::String)#File.exist?(image_path)
         image = ImageProcessor.new(media_file)
         # Create a tempfile here that will be kept open for the duration of the block
         # this is used in #apply to hold a copy of the processed image data rather than
@@ -205,32 +225,14 @@ module Spontaneous
         result.serialize
       end
 
-      def preprocess(image_path)
-        filename = mimetype = nil
-        case image_path
-        when Hash
-          mimetype = image_path[:type]
-          filename = image_path[:filename]
-          image_path = image_path[:tempfile].path
-        when String
-          # return image_path unless File.exist?(image_path)
-          filename = ::File.basename(image_path)
-        end
-        return image_path unless File.exist?(image_path)
-        # media_path = owner.make_media_file(image_path, filename)
-        media_file = Spontaneous::Media::File.new(owner, filename, mimetype)
-        media_file.copy(image_path)
-        set_unprocessed_value(File.expand_path(media_file.filepath))
-        # media_path
-        # image_path
-        media_file
-      end
 
       def export(user = nil)
         super(user).merge({
           :processed_value => processed_values
         })
       end
+
+      self.register(:image, :photo)
     end
 
 
@@ -314,7 +316,7 @@ module Spontaneous
         end
 
         def composite(other_image_path, output_extension = "jpg", &block)
-          File.open(other_image_path) do |other_image|
+          ::File.open(other_image_path) do |other_image|
             new_image = image.composite(other_image, output_extension, &block)
             image.path = new_image.path
           end
@@ -398,7 +400,7 @@ module Spontaneous
       end
 
       def filesize
-        File.size(path)
+        ::File.size(path)
       end
 
       def width
@@ -446,7 +448,7 @@ module Spontaneous
           :width => width,
           :height => height,
           :filesize => filesize,
-          :path => path
+          :path => @media_file.path
         }
       end
 
@@ -455,7 +457,5 @@ module Spontaneous
       end
     end
 
-    ImageField.register(:image, :photo)
 
-  end
 end

data/lib/spontaneous/{field_types/location_field.rb → field/location.rb}

@@ -2,8 +2,8 @@
 
 require 'open-uri'
 
-module Spontaneous::FieldTypes
-  class LocationField < StringField
+module Spontaneous::Field
+  class Location < String
 
     def outputs
       [:html, :lat, :lng]

data/lib/spontaneous/{field_types/long_string_field.rb → field/long_string.rb}

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-module Spontaneous::FieldTypes
-  class LongStringField < Field
-    include Spontaneous::Plugins::Field::EditorClass
+module Spontaneous::Field
+  class LongString < Base
+    has_editor
 
     def generate_html(value)
       escape_html(value).gsub(/[\r\n]+/, "<br />")

data/lib/spontaneous/field/markdown.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+require 'kramdown'
+
+module Spontaneous::Field
+  class Markdown < Base
+    has_editor
+
+    def outputs
+      [:html]
+    end
+
+    def generate_html(input)
+      input.to_html
+    end
+
+    def preprocess(input)
+      # convert lines ending with newlines into a <br/>
+      # as official Markdown syntax isn't suitable for
+      # casual users
+      # code taken from:
+      # http://github.github.com/github-flavored-markdown/
+      output = input.gsub(/^[\w\<][^\n]*\n+/) do |x|
+        x =~ /\n{2}/ ? x : (x.strip!; x << "  \n")
+      end
+
+      # prevent foo_bar_baz from ending up with an italic word in the middle
+      output.gsub!(/(^(?! {4}|\t)\w+_\w+_\w[\w_]*)/) do |x|
+        x.gsub('_', '\_') if x.split('').sort.to_s[0..1] == '__'
+      end
+      Kramdown::Document.new(output)
+    end
+
+    self.register(:markdown, :text, :richtext)
+  end
+end

data/lib/spontaneous/{field_types/select_field.rb → field/select.rb}

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-module Spontaneous::FieldTypes
+module Spontaneous::Field
   # Provides a select field in the UI.
   #
   # Options for the select are provided by passing an :options value in the field config.
@@ -35,8 +35,8 @@ module Spontaneous::FieldTypes
   # To retrieve the associated label use `field.value(:label)` or `field.label`
   # ("Value 1" or "Value 2" in the exampel above).
   #
-  class SelectField < Field
-    include Spontaneous::Plugins::Field::EditorClass
+  class Select < Base
+    has_editor
 
     def self.static_option_list?
       return false if configured_option_list.is_a?(Proc)
@@ -104,6 +104,5 @@ module Spontaneous::FieldTypes
     end
 
     self.register
-  end # OptionsField
+  end # Select
 end
-

data/lib/spontaneous/field/string.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+  class String < Base
+    has_editor
+
+    def preprocess(value)
+      Spontaneous::Utils::SmartQuotes.smarten(value.to_s)
+    end
+
+    def generate_html(value)
+      escape_html(value)
+    end
+
+    self.register :string, :title
+  end
+end

data/lib/spontaneous/field/update.rb

@@ -0,0 +1,156 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+
+  class Update
+    def self.perform(fields, user, asynchronous = false)
+      self.new(fields, user).run(asynchronous)
+    end
+
+
+    def self.asynchronous_update_class
+      Spontaneous::Site.resolve_background_mode(self)
+    end
+
+    def initialize(fields, user)
+      @fields, @user = fields, user
+    end
+
+    def run(asynchronous = false)
+      fields.each do |field, value|
+        field.pending_value = value
+      end
+
+      immediate, asynchronous = partition_fields(asynchronous)
+
+      Immediate.process(immediate)
+
+      launch_asynchronous_update(asynchronous)
+    end
+
+    def partition_fields(asynchronous)
+      fields = self.fields.keys
+      return [fields, []] unless asynchronous
+      filter    = proc { |f| f.asynchronous? }
+      async     = fields.select(&filter)
+      immediate = fields.reject(&filter)
+      [immediate, async]
+    end
+
+    def fields
+      writable_fields
+    end
+
+    def owners(fields)
+      fields.map(&:owner).uniq
+    end
+
+    def writable_fields
+      @fields.reject { |f, v| !f.writable?(@user)}
+    end
+
+    def launch_asynchronous_update(fields)
+      return if fields.empty?
+      # Keep the saving command here rather than in the field
+      # because all the fields most probably belong to
+      # the same owner
+      owners(fields).each(&:save_fields)
+      fields.each do |field|
+        prepare_asynchronous_update(field)
+      end
+      updater = self.class.asynchronous_update_class
+      updater.process(fields)
+    end
+
+    def prepare_asynchronous_update(field)
+      field.before_asynchronous_update
+      Spontaneous::PageLock.lock_field(field)
+    end
+
+    class Immediate
+      def self.process(fields)
+        self.new(fields).run
+      end
+
+      def initialize(fields)
+        @fields = Array(fields)
+      end
+
+      def run
+        @fields.each do |field|
+          field.process_pending_value
+        end
+        save
+      end
+
+      # This is made more complex by the need to verify that:
+      #
+      #   a. this update has not been superceded by a more recent one and
+      #   b. other fields on the owner have not been updated synchronously since
+      #      this update was launched.
+      #
+      # (a) is verified by only saving fields that pass the #validate_update!
+      # test.
+      #
+      # (b) by calling Content#save_fields on a reloaded version of the owner
+      # and by the fact that only the fields that have been modified by this
+      # updater are re-serialized.
+      #
+      def save
+        valid_fields = @fields.reject { |field| field.conflicted_update? }
+        remove_update_lock(valid_fields)
+        field_map = valid_fields.group_by { |f| f.owner }
+        field_map.each do |owner, fields|
+          reload(owner).save_fields(fields)
+        end
+      end
+
+      # We need to save against a fresh version of the owning content
+      # because with long-running updates (video transcoding for example)
+      # it's quite likely that some non-asynchronous fields have been modified
+      # during the processing period.
+      #
+      # The #save_fields method only re-serializes the fields it's passed
+      # so we can update the fields we have updated without over-writing the db
+      # versions of any other fields.
+      def reload(owner)
+        Spontaneous::Content.scope! do
+          o = Spontaneous::Content.get(owner.content_instance.id)
+          return o.boxes[owner.box_name] if Spontaneous::Box === owner
+          o
+        end
+      end
+
+
+      def remove_update_lock(fields)
+        fields.each do |field|
+          Spontaneous::PageLock.unlock_field(field)
+        end
+      end
+
+      def owners
+        @fields.map(&:owner).uniq.compact
+      end
+
+      # Load these everytime to ensure they are updated with their
+      # correct lock status
+      def pages
+        page_ids = owners.map(&:page).uniq.compact.map(&:id)
+        page_ids.map { |id| Spontaneous::Content.get(id) }
+      end
+    end
+
+    class Simultaneous < Immediate
+      def run
+        params = { "fields" => @fields.map { |f| f.id } }
+        begin
+          Spontaneous::Simultaneous.fire(:update_fields, params)
+        rescue Spontaneous::Simultaneous::Error
+          Immediate.process(@fields)
+        end
+      end
+    end
+  end
+end
+
+Spontaneous::Simultaneous.register(:update_fields, "field update", :logfile => "log/fields.log")