spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/field/base.rb

@@ -2,8 +2,8 @@ module Spontaneous
   module Field
     class Base
       module ClassMethods
-        def has_editor
-          define_singleton_method(:editor_class) { ui_class }
+        def has_editor(js_class = ui_class)
+          define_singleton_method(:editor_class) { js_class }
         end
 
         def register(*labels)
@@ -44,6 +44,10 @@ module Spontaneous
           end
         end
 
+        def default_options
+          {}
+        end
+
         # Provides the ability for specific field types to customize the schema values
         # they return to the UI
         def export(user)
@@ -54,20 +58,57 @@ module Spontaneous
       extend ClassMethods
 
       attr_accessor :owner, :name, :unprocessed_value, :template_params, :version
-      attr_reader   :processed_values
-
-      alias_method :values, :processed_values
+      attr_accessor :prototype
 
 
       def initialize(params={}, default_values=true)
         @processed_values = {}
         deserialize(params, default_values)
+        @values = nil
+      end
+
+      def processed_values
+        @values ||= processed_values_with_fallback
+      end
+
+      alias_method :values, :processed_values
+
+      ValueHash = Spontaneous::Collections::HashWithFallback
+
+      def processed_values_with_fallback
+        return @processed_values if owner.nil? || prototype.fallback.nil?
+        fallback = owner.fields[prototype.fallback]
+        if fallback.nil?
+          logger.warn("Missing field '#{prototype.fallback}' specified as fallback for field #{owner.class}::#{name}")
+          return @processed_values
+        end
+        test     = proc { |val| self.blank? }
+        ValueHash.new(fallback, test).update(@processed_values)
+      end
+
+      def [](key)
+        processed_values[key]
       end
 
       def id
         [owner.id, schema_id].join("/")
       end
 
+      # This is used exclusively to compute the filename/path of
+      # temp files.
+      #
+      # To avoid creating a deep hierarchy under /media/tmp
+      # which would be hard to cleanup we replace all dir separators
+      # with underscores.
+      #
+      # The timestamp is added because otherwise serial modifications
+      # to the same field might overwrite the value (though this is
+      # unlikely)
+      def media_id
+        ids = [owner.id, schema_id, timestamp]
+        ids.join("_").gsub(/\//, "_")
+      end
+
       def writable?(user)
         owner.field_writable?(user, name)
       end
@@ -83,10 +124,18 @@ module Spontaneous
         values[:__pending__] = {
           :value => value,
           :version => version + 1,
-          :timestamp => Spontaneous::Field.timestamp
+          :timestamp => timestamp
         }
       end
 
+      # A timestamp value consistent for a particular field instance
+      #
+      # This is used to solve conflicts for async updates and to
+      # tag a tempfile to a particular pending value.
+      def timestamp
+        @timestamp ||= Spontaneous::Field.timestamp
+      end
+
       def pending_value
         values[:__pending__]
       end
@@ -100,23 +149,39 @@ module Spontaneous
       end
 
       def process_pending_value
-        process_pending_value!
+        if (pending = process_pending_value!)
+          cleanup_pending_value!(pending)
+        end
         save
       end
 
       def process_pending_value!
         if has_pending_value?
+          pending = pending_value
           @previous_values = values.dup
           set_value!(pending_value[:value])
+          pending
         end
       end
 
+      # Ensures that this update can still run
+      def invalid_update?
+        return true if reload.nil?
+        false
+      end
+
+      # Ensures that the pending value we have hasn't been superceded by
+      # a later one.
       def conflicted_update?
         return false if is_valid_pending_value?
         self.processed_values = @previous_values
         true
       end
 
+      # Reloads the field and compares the timestamps -- if our timestamp
+      # is the same or greater than the reloaded value then we are the
+      # most up-to-date update available. If not then we're not and
+      # should abort.
       def is_valid_pending_value?
         return true if @previous_values.nil?
         reloaded = reload
@@ -131,6 +196,15 @@ module Spontaneous
         end
       end
 
+      def cleanup_pending_value!(pending)
+        clear_pending_value
+        if pending && (v = pending[:value]) && v.is_a?(Hash)
+          if (tempfile = v[:tempfile]) && ::File.exist?(tempfile)
+            FileUtils.rm_r(::File.dirname(tempfile))
+          end
+        end
+      end
+
       def reload
         Spontaneous::Content.scope! do
           Spontaneous::Field.find(self.id)
@@ -230,8 +304,11 @@ module Spontaneous
       # override this to return custom values derived from (un)processed_value
       # alias_method :value, :processed_value
       def value(format=:html)
-        processed_values[format.to_sym] || unprocessed_value
+        format = format.to_sym
+        return unprocessed_value unless processed_values.key?(format)
+        processed_values[format]
       end
+
       alias_method :processed_value, :value
 
       def image?
@@ -280,11 +357,6 @@ module Spontaneous
         @modified
       end
 
-      attr_accessor :prototype
-      # def prototype
-      #   self.class.prototype
-      # end
-
       def schema_id
         self.prototype.schema_id
       end
@@ -397,6 +469,7 @@ module Spontaneous
       end
 
       def processed_values=(values)
+        @values = nil
         @processed_values = values
       end
 

data/lib/spontaneous/field/boolean.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+  class Boolean < Base
+    has_editor "Spontaneous.Field.Boolean"
+
+    def self.default_options
+      {default: true, true: "Yes", false: "No"}
+    end
+
+    def self.export(user)
+      super.merge({
+        labels: { true: prototype.options[:true], false: prototype.options[:false] }
+      })
+    end
+
+    def outputs
+      [:boolean, :html, :string]
+    end
+
+    def value(format = :boolean)
+      super(format)
+    end
+
+    def checked?
+      value(:boolean)
+    end
+
+    alias_method :on?, :checked?
+    alias_method :enabled?, :checked?
+
+    def preprocess(value)
+      case value
+      when TrueClass, FalseClass
+        value
+      when "", nil
+        o = self.class.prototype.options
+        return o[:default] if o.key?(:default)
+        true
+      when "1", "true"
+        true
+      else
+        false
+      end
+    end
+
+    def generate_boolean(state)
+      state
+    end
+
+    def generate_html(state)
+      string_value(state)
+    end
+
+    def generate_string(state)
+      string_value(state)
+    end
+
+    def string_value(state)
+      self.class.prototype.options[(state ? :true : :false)]
+    end
+
+    self.register(:boolean, :switch)
+  end
+end

data/lib/spontaneous/field/file.rb

@@ -11,7 +11,7 @@ module Spontaneous::Field
     end
 
     def outputs
-      [:html, :filesize, :filename]
+      [:html, :path, :filesize, :filename]
     end
 
     def pending_value=(value)
@@ -30,7 +30,15 @@ module Spontaneous::Field
     end
 
     def serialize_pending_file(file)
-      { :tempfile => file.path, :type => file.mimetype, :filename => file.filename, :src => file.url }
+      { :tempfile => file.path, :type => file.mimetype, :filename => file.filename, :filesize => file.filesize, :src => file.url }
+    end
+
+    def storage_headers(content_type, filename)
+      headers = { content_type: content_type }
+      if prototype.options[:attachment]
+        headers.update(content_disposition: %(attachment; filename=#{Rack::Utils.escape(filename)}))
+      end
+      headers
     end
 
     def preprocess(image)
@@ -38,7 +46,7 @@ module Spontaneous::Field
       return "" if file.nil?
       return file unless ::File.exist?(file)
 
-      media_file = Spontaneous::Media::File.new(owner, filename, mimetype)
+      media_file = Spontaneous::Media::File.new(owner, filename, storage_headers(mimetype, filename))
       media_file.copy(file)
       set_unprocessed_value(media_file.path)
       media_file
@@ -46,7 +54,7 @@ module Spontaneous::Field
 
     def process_upload(value)
       file, filename, mimetype = fileinfo(value)
-      media_file = Spontaneous::Media::TempFile.new(owner, filename, mimetype)
+      media_file = Spontaneous::Media::TempFile.new(self, filename, storage_headers(mimetype, filename))
       media_file.copy(file)
       media_file
     end
@@ -63,7 +71,6 @@ module Spontaneous::Field
       [file, filename, mimetype]
     end
 
-
     def generate_filesize(input)
       if input.respond_to?(:filesize)
         input.filesize
@@ -80,11 +87,15 @@ module Spontaneous::Field
       end
     end
 
-    def generate_html(input)
+    def generate_path(input)
       return input if input.is_a?(::String)
       input.url
     end
 
+    def generate_html(input)
+      generate_path(input)
+    end
+
     def export(user = nil)
       super(user).merge({
         :processed_value => processed_values

data/lib/spontaneous/field/html.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+  class HTML < LongString
+
+    # Just pass through the value without any kind of escaping
+    def generate_html(value)
+      value
+    end
+
+    self.register
+  end
+end

data/lib/spontaneous/field/image/size.rb

@@ -0,0 +1,76 @@
+module Spontaneous::Field
+  class Image
+    class Size
+      include Spontaneous::Media::Image::Renderable
+
+      attr_reader :path
+
+      def initialize(input, name, options, process)
+        @input, @name, @process = input, name, process
+        @options = {:optimize => true}.merge(options)
+      end
+
+      def generate
+        tempfile do |tempfile|
+          convert(tempfile)
+          file = @input.rename(filename)
+          file.copy(tempfile)
+          serialize(file)
+        end
+      end
+
+      def serialize(file)
+        values = file.serialize
+        path = values.delete(:path)
+        src  = values.delete(:url)
+        image = Spontaneous::Media::Image.new(file.source)
+        values.update(image.attributes).update(:src => src)
+      end
+
+      def convert(tempfile)
+        processor = Spontaneous::Media::Image::Processor.new(path, tempfile.path)
+        processor.apply(process)
+        optimize(tempfile) if @options[:optimize]
+      end
+
+      def optimize(tempfile)
+        Spontaneous::Media::Image::Optimizer.run(tempfile.path)
+      end
+
+      def process
+        @process || Proc.new {  }
+      end
+
+      def path
+        @input.source
+      end
+
+      def extname
+        (format = @options[:format]) ? ".#{format}" : @input.extname
+      end
+
+      def tempfile(&block)
+        dir  = Dir.mktmpdir
+        name = "#{@name}#{extname}"
+        path = ::File.join(dir, name)
+        ::File.open(path, "w+b") do |file|
+          block.call file
+        end
+      ensure
+        FileUtils.rm_rf(dir) rescue nil
+      end
+
+      def filename
+        original_filename = @input.filename
+        parts = original_filename.split('.')
+        base = parts[0..-2].join('.')
+        size = @name == :original ? "" : ".#{@name}"
+        "#{base}#{size}#{extname}"
+      end
+
+      def inspect
+        %(#<Spontaneous::Field::Image::Size name=:#{@name} options=#{@options.inspect}>)
+      end
+    end
+  end
+end