spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/field/boolean.rb

@@ -29,7 +29,7 @@ module Spontaneous::Field
     alias_method :on?, :checked?
     alias_method :enabled?, :checked?
 
-    def preprocess(value)
+    def preprocess(value, site)
       case value
       when TrueClass, FalseClass
         value
@@ -44,15 +44,15 @@ module Spontaneous::Field
       end
     end
 
-    def generate_boolean(state)
+    def generate_boolean(state, site)
       state
     end
 
-    def generate_html(state)
+    def generate_html(state, site)
       string_value(state)
     end
 
-    def generate_string(state)
+    def generate_string(state, site)
       string_value(state)
     end
 

data/lib/spontaneous/field/date.rb

@@ -26,7 +26,7 @@ module Spontaneous::Field
       [:julian]
     end
 
-    def preprocess(value)
+    def preprocess(value, site)
       return value if value.blank?
       ::Date.parse(value)
     end
@@ -35,7 +35,7 @@ module Spontaneous::Field
       %(<time datetime="%Y-%m-%d">#{ format }</time>)
     end
 
-    def generate_julian(date)
+    def generate_julian(date, site)
       return date.jd if date.is_a?(::Date)
       date.to_s
     end

data/lib/spontaneous/field/file.rb

@@ -6,7 +6,10 @@ module Spontaneous::Field
   class File < Base
     has_editor
 
+    # In the case of clearing the field we will have been given a pending_value of ""
+    # we don't want that to run asynchronously
     def asynchronous?
+      return false if (pending_value && pending_value[:value].blank?)
       true
     end
 
@@ -14,15 +17,17 @@ module Spontaneous::Field
       [:html, :path, :filesize, :filename]
     end
 
-    def pending_value=(value)
-      file = process_upload(value)
+    def set_pending_value(value, site)
+      file = process_upload(value, site)
       pending = case file
+        when nil
+          ""
         when String
           { :tempfile => file }
         else
           serialize_pending_file(file)
         end
-      super(pending)
+      super(pending, site)
     end
 
     def page_lock_description
@@ -35,30 +40,31 @@ module Spontaneous::Field
 
     def storage_headers(content_type, filename)
       headers = { content_type: content_type }
-      if prototype.options[:attachment]
+      if prototype && prototype.options[:attachment]
         headers.update(content_disposition: %(attachment; filename=#{Rack::Utils.escape(filename)}))
       end
       headers
     end
 
-    def preprocess(image)
+    def process_upload(value, site)
+      return nil if value.blank?
+      file, filename, mimetype = fileinfo(value)
+      media_file = site.tempfile(self, filename, storage_headers(mimetype, filename))
+      media_file.copy(file)
+      media_file
+    end
+
+    def preprocess(image, site)
       file, filename, mimetype = fileinfo(image)
       return "" if file.nil?
       return file unless ::File.exist?(file)
 
-      media_file = Spontaneous::Media::File.new(owner, filename, storage_headers(mimetype, filename))
+      media_file = site.file(owner, filename, storage_headers(mimetype, filename))
       media_file.copy(file)
       set_unprocessed_value(media_file.path)
       media_file
     end
 
-    def process_upload(value)
-      file, filename, mimetype = fileinfo(value)
-      media_file = Spontaneous::Media::TempFile.new(self, filename, storage_headers(mimetype, filename))
-      media_file.copy(file)
-      media_file
-    end
-
     def fileinfo(fileinfo)
       file = filename = mimetype = nil
       case fileinfo
@@ -71,7 +77,7 @@ module Spontaneous::Field
       [file, filename, mimetype]
     end
 
-    def generate_filesize(input)
+    def generate_filesize(input, site)
       if input.respond_to?(:filesize)
         input.filesize
       else
@@ -79,7 +85,7 @@ module Spontaneous::Field
       end
     end
 
-    def generate_filename(input)
+    def generate_filename(input, site)
       if input.respond_to?(:filename)
         input.filename
       else
@@ -87,13 +93,13 @@ module Spontaneous::Field
       end
     end
 
-    def generate_path(input)
+    def generate_path(input, site)
       return input if input.is_a?(::String)
       input.url
     end
 
-    def generate_html(input)
-      generate_path(input)
+    def generate_html(input, site)
+      generate_path(input, site)
     end
 
     def export(user = nil)

data/lib/spontaneous/field/html.rb

@@ -4,7 +4,7 @@ module Spontaneous::Field
   class HTML < LongString
 
     # Just pass through the value without any kind of escaping
-    def generate_html(value)
+    def generate_html(value, site)
       value
     end
 

data/lib/spontaneous/field/image.rb

@@ -15,23 +15,10 @@ module Spontaneous::Field
       %w{image/(png|jpeg|gif)}
     end
 
-    class TemplateParameters < DelegateClass(S::Media::Image::Attributes)
-      attr_reader :image
-
-      def initialize(image, args)
-        super(image)
-        @image, @args = image, args.extract_options!
-      end
-
-      def to_html(attributes = {})
-        @image.to_html(@args.merge(attributes))
-      end
-    end
-
     def self.size(name, options = {}, &process)
       self.sizes[name.to_sym] = [options, process]
       unless method_defined?(name)
-        class_eval "def #{name}(*args); TemplateParameters.new(sizes[:#{name}], args); end"
+        class_eval "def #{name}(*args); sizes[:#{name}]; end"
       end
     end
 
@@ -91,15 +78,15 @@ module Spontaneous::Field
     end
 
     def width
-      original.width
+      original.width || 0
     end
 
     def height
-      original.height
+      original.height || 0
     end
 
     def filesize
-      original.filesize
+      original.filesize || 0
     end
 
     def src
@@ -119,12 +106,12 @@ module Spontaneous::Field
       sizes[:original].src
     end
 
-    def set_value!(value, process = true)
+    def set_value!(value, process = true, site = nil)
       @sizes = nil
       super
     end
 
-    def generate(name, media_file)
+    def generate(name, media_file, site)
       return { :src => media_file } if media_file.is_a?(::String)
       options, process = self.class.size_definitions[name]
       size = Size.new(media_file, name, options, process)

data/lib/spontaneous/field/location.rb

@@ -9,7 +9,7 @@ module Spontaneous::Field
       [:html, :lat, :lng]
     end
 
-    def generate_outputs(input)
+    def generate_outputs(input, site)
       values = {}
       values[:html] = escape_html(input)
       values.update(geolocate(input))

data/lib/spontaneous/field/long_string.rb

@@ -4,10 +4,10 @@ module Spontaneous::Field
   class LongString < Base
     has_editor
 
-    def generate_html(value)
-      escape_html(value).gsub(/[\r\n]+/, "<br />")
+    def generate_html(value, site)
+      escape_html(value).gsub(/[\r\n]+/, "<br />\n")
     end
 
-    self.register
+    self.register(:long_string, :longstring, :text)
   end # LongStringField
 end

data/lib/spontaneous/field/markdown.rb

@@ -10,11 +10,11 @@ module Spontaneous::Field
       [:html]
     end
 
-    def generate_html(input)
+    def generate_html(input, site)
       input.to_html
     end
 
-    def preprocess(input)
+    def preprocess(input, site)
       # convert lines ending with newlines into a <br/>
       # as official Markdown syntax isn't suitable for
       # casual users
@@ -31,6 +31,6 @@ module Spontaneous::Field
       Kramdown::Document.new(output)
     end
 
-    self.register(:markdown, :text, :richtext)
+    self.register(:markdown, :markup, :richtext)
   end
 end

data/lib/spontaneous/field/select.rb

@@ -86,12 +86,12 @@ module Spontaneous::Field
       [:html, :label]
     end
 
-    def generate(output, value)
+    def generate(output, value, site)
       return "" if value.blank?
       value[[:html, :label].index(output)]
     end
 
-    def preprocess(value)
+    def preprocess(value, site)
       Spontaneous::JSON.parse(value)
     end
 

data/lib/spontaneous/field/string.rb

@@ -4,11 +4,11 @@ module Spontaneous::Field
   class String < Base
     has_editor
 
-    def preprocess(value)
+    def preprocess(value, site)
       Spontaneous::Utils::SmartQuotes.smarten(value.to_s)
     end
 
-    def generate_html(value)
+    def generate_html(value, site)
       escape_html(value)
     end
 

data/lib/spontaneous/field/tags.rb

@@ -12,13 +12,13 @@ module Spontaneous::Field
       [:html, :tags]
     end
 
-    def generate_html(value)
+    def generate_html(value, site)
       value
     end
 
     TAG_PARSER_RE = /"([^"]+)"|([^ ]+)/
 
-    def generate_tags(value)
+    def generate_tags(value, site)
       return [] if value.blank?
       (value).scan(TAG_PARSER_RE).flatten.compact
     end

data/lib/spontaneous/field/update.rb

@@ -3,27 +3,27 @@
 module Spontaneous::Field
 
   class Update
-    def self.perform(fields, user, asynchronous = false)
-      self.new(fields, user).run(asynchronous)
+    def self.perform(site, fields, user, asynchronous = false)
+      self.new(site, fields, user).run(asynchronous)
     end
 
 
-    def self.asynchronous_update_class
-      Spontaneous::Site.resolve_background_mode(self)
+    def self.asynchronous_update_class(site)
+      site.resolve_background_mode(self)
     end
 
-    def initialize(fields, user)
-      @fields, @user = fields, user
+    def initialize(site, fields, user)
+      @site, @fields, @user = site, fields, user
     end
 
     def run(asynchronous = false)
       fields.each do |field, value|
-        field.pending_value = value
+        field.set_pending_value(value, @site)
       end
 
       immediate, asynchronous = partition_fields(asynchronous)
 
-      Immediate.process(immediate)
+      Immediate.process(@site, immediate)
 
       launch_asynchronous_update(asynchronous)
     end
@@ -58,8 +58,8 @@ module Spontaneous::Field
       fields.each do |field|
         prepare_asynchronous_update(field)
       end
-      updater = self.class.asynchronous_update_class
-      updater.process(fields)
+      updater = self.class.asynchronous_update_class(@site)
+      updater.process(@site, fields)
     end
 
     def prepare_asynchronous_update(field)
@@ -68,17 +68,17 @@ module Spontaneous::Field
     end
 
     class Immediate
-      def self.process(fields)
-        self.new(fields).run
+      def self.process(site, fields)
+        self.new(site, fields).run
       end
 
-      def initialize(fields)
-        @fields = Array(fields)
+      def initialize(site, fields)
+        @site, @fields = site, Array(fields)
       end
 
       def run
         @fields.each do |field|
-          field.process_pending_value
+          field.process_pending_value(@site)
         end
         save
       end
@@ -114,8 +114,8 @@ module Spontaneous::Field
       # 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)
+        owner.model.scope! do
+          o = owner.model.get(owner.content_instance.id)
           return o.boxes[owner.box_name] if Spontaneous::Box === owner
           o
         end
@@ -135,8 +135,9 @@ module Spontaneous::Field
       # 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) }
+        pages = owners.map { |owner| [owner.model, owner.page] }.uniq
+        pages = pages.reject { |model, page| page.nil? }.map { |model, page| [model, page.id] }
+        pages.map { |model, id| model.get(id) }
       end
     end
 
@@ -146,7 +147,7 @@ module Spontaneous::Field
         begin
           Spontaneous::Simultaneous.fire(:update_fields, params)
         rescue Spontaneous::Simultaneous::Error
-          Immediate.process(@fields)
+          Immediate.process(@site, @fields)
         end
       end
     end

data/lib/spontaneous/field/webvideo.rb

@@ -97,7 +97,7 @@ module Spontaneous::Field
       values[:video_id]
     end
 
-    def generate_outputs(input)
+    def generate_outputs(input, site)
       values = {}
       values[:html] = escape_html(input)
 
@@ -109,19 +109,19 @@ module Spontaneous::Field
       values.merge(metadata || {})
     end
 
-    def render(format=:html, *args)
+    def render(format=:html, locals = {}, *args)
       case format
       when :html
-        to_html(*args)
+        to_html(locals)
       when :json
-        to_json(*args)
+        to_json(locals)
       else
         value(format)
       end
     end
 
-    def to_html(*args)
-      provider.to_html(*args)
+    def to_html(locals = {})
+      provider.to_html(locals)
     end
 
     def provider_id