spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/field/image.rb

@@ -4,458 +4,143 @@ require 'tempfile'
 require 'mini_magick'
 require 'delegate'
 
-module Spontaneous::Field
-
-    class ImageOptimizer
-      def self.run(source_image)
-        self.new(source_image).run
-      end
-
-      def self.jpegtran_binary
-        @jpegtran ||= find_binary("jpegtran")
-      end
-
-      def self.jpegoptim_binary
-        @jpegoptim ||= find_binary("jpegoptim")
-      end
 
-      def self.find_binary(name)
-        binary = `which #{name}`.chomp
-        return nil if binary.length == 0
-        binary
-      end
-
-      # def self.find_binary(name)
-      #   binaries = ["/usr/bin/env #{name}"]
-      #   puts "testing name #{name}"
-      #   binaries.detect { |bin| status = Spontaneous.system("#{bin} -h"); p status; status == 1  }.tap do |b|
-      #     puts "found #{b.inspect}"
-      #   end
-      # end
-
-      def initialize(source_image)
-        @source_image = source_image
-      end
-
-      def run
-        jpegoptim!(@source_image)
-        jpegtran!(@source_image)
-      end
+module Spontaneous::Field
+  class Image < File
+    autoload :Size, 'spontaneous/field/image/size'
 
-      def jpegoptim!(input)
-        run_optimization(self.class.jpegoptim_binary, "-o -q --strip-all --preserve --force #{input} 2>&1 1>/dev/null")
-      end
+    include Spontaneous::Media::Image::Renderable
 
-      def jpegtran!(input)
-        run_optimization(self.class.jpegtran_binary, "-optimize -progressive -copy none -outfile #{input} #{input}")
-      end
+    has_editor
 
-      def run_optimization(binary, args)
-        return unless binary
-        command = [binary, args].join(" ")
-        Spontaneous.system(command)
-      end
+    def self.accepts
+      %w{image/(png|jpeg|gif)}
     end
 
-    module ImageFieldUtilities
-      attr_accessor :template_params
+    class TemplateParameters < DelegateClass(S::Media::Image::Attributes)
+      attr_reader :image
 
-      def render(format=:html, *args)
-        case format
-        when "html", :html
-          to_html(*args)
-        else
-          value
-        end
+      def initialize(image, args)
+        super(image)
+        @image, @args = image, args.extract_options!
       end
 
-      def to_html(attr={})
-        default_attr = {
-          :src => src,
-          :width => width,
-          :height => height,
-          :alt => ""
-        }
-        default_attr.delete(:width) if width.nil?
-        default_attr.delete(:height) if height.nil?
-        if template_params && template_params.length > 0 && template_params[0].is_a?(Hash)
-          attr = template_params[0].merge(attr)
-        end
-        if attr.key?(:width) || attr.key?(:height)
-          default_attr.delete(:width)
-          default_attr.delete(:height)
-          if (attr.key?(:width) && !attr[:width]) || (attr.key?(:height) && !attr[:height])
-            attr.delete(:width)
-            attr.delete(:height)
-          end
-        end
-        attr = default_attr.merge(attr)
-        params = []
-        attr.each do |name, value|
-          params << %(#{name}="#{value.to_s.escape_html}")
-        end
-        %(<img #{params.join(' ')} />)
-      end
-
-      def to_s
-        src
-      end
-
-      def /(value)
-        return value if self.blank?
-        self
+      def to_html(attributes = {})
+        @image.to_html(@args.merge(attributes))
       end
     end
 
-    class Image < File
-      has_editor
-      include ImageFieldUtilities
-
-      def self.accepts
-        %w{image/(png|jpeg|gif)}
-      end
-
-      def self.size(name, &process)
-        self.sizes[name.to_sym] = process
-
-        unless method_defined?(name)
-          class_eval <<-IMAGE
-            def #{name}
-              sizes[:#{name}]
-            end
-          IMAGE
-        end
-      end
-
-      def self.sizes
-        size_definitions
-      end
-
-      def self.validate_sizes(sizes)
-        sizes
-      end
-
-      def self.size_definitions
-        @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?
-        true
-      end
-
-      def sizes
-        @sizes ||= Hash.new { |hash, key| hash[key] = ImageAttributes.new(processed_values[key]) }
-      end
-
-      # value used to show conflicts between the current value and the value they're attempting to enter
-      def conflicted_value
-        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]
-      end
-
-      def width
-        original.width
-      end
-
-      def height
-        original.height
-      end
-
-      def filesize
-        original.filesize
+    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"
       end
+    end
 
-      def src
-        original.src
-      end
-
-      def filepath
-        unprocessed_value
-      end
-
-      # formats are irrelevant to image/file fields
-      def outputs
-        [: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)
-        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
-        # rely on the minimagick generated tempfiles which can get closed
-        result = Tempfile.open("image_#{output}") do |tempfile|
-          case output
-          when :original
-            image
-          else
-            process = self.class.size_definitions[output]
-            image.apply(process, output, tempfile)
-          end
-        end
-        result.serialize
-      end
-
-
-      def export(user = nil)
-        super(user).merge({
-          :processed_value => processed_values
-        })
-      end
+    def self.sizes
+      size_definitions
+    end
 
-      self.register(:image, :photo)
+    def self.validate_sizes(sizes)
+      sizes
     end
 
+    def self.size_definitions
+      @size_definitions ||= superclass.respond_to?(:size_definitions) ? superclass.size_definitions.dup : default_size_definitions
+    end
 
-    class ImageAttributes
-      include ImageFieldUtilities
+    def self.default_size_definitions
+      { :original => original_size, :__ui__ => ui_preview_size }
+    end
 
-      attr_reader  :src, :width, :height, :filesize, :filepath
+    def self.original_size
+      [ {} ]
+    end
 
-      def initialize(params={})
-        params ||= {}
-        @src, @width, @height, @filesize, @filepath = params[:src], params[:width], params[:height], params[:filesize], params[:path]
-      end
+    def self.ui_preview_size
+      [ {}, proc { width 300 } ]
+    end
 
-      def serialize
-        {
-          :src => src,
-          :width => width,
-          :height => height,
-          :filesize => filesize,
-          :path => filepath
-        }
-      end
+    def image?
+      true
+    end
 
-      def inspect
-        %(<#{self.class.name}: src=#{src.inspect} width="#{width}" height="#{height}">)
-      end
+    def sizes
+      @sizes ||= Hash.new { |hash, key| hash[key] = S::Media::Image::Attributes.new(processed_values[key]) }
+    end
 
-      def blank?
-        src.blank?
-      end
+    # value used to show conflicts between the current value and the value they're attempting to enter
+    def conflicted_value
+      value
+    end
 
-      alias_method :empty?, :blank?
+    # I want to merge the file info available in the media file
+    # with the image details (width, height etc)
+    def serialize_pending_file(file)
+      attrs = file.serialize
+      url   = attrs.delete(:url)
+      image = Spontaneous::Media::Image.new(file.path)
+      attrs.merge(image.serialize).merge(super)
     end
 
-    class ImageProcessor
-      include ImageFieldUtilities
-
-      class ImageDelegator < SimpleDelegator
-
-        def initialize(image)
-          super(image)
-        end
-
-        alias_method :image, :__getobj__
-
-        def format(*args, &block)
-          image.format(*args, &block)
-        end
-
-        def fit(width, height)
-          image.combine_options do |c|
-            c.add_command(:geometry, "#{width}x#{height}>")
-          end
-        end
-
-        def crop(width, height)
-          image.combine_options do |c|
-            dimensions = "#{width}x#{height}"
-            c.add_command(:geometry, "#{dimensions}^")
-            c.add_command(:gravity, "center")
-            c.add_command(:crop, "#{dimensions}+0+0!")
-          end
-        end
-
-        def width(width)
-          image.combine_options do |c|
-            c.add_command(:geometry, "#{width}x>")
-          end
-        end
-
-        def height(height)
-          image.combine_options do |c|
-            c.add_command(:geometry, "x#{height}>")
-          end
-        end
-
-        def greyscale
-          image.combine_options do |c|
-            c.add_command(:type, "Grayscale")
-          end
-        end
-
-        def composite(other_image_path, output_extension = "jpg", &block)
-          ::File.open(other_image_path) do |other_image|
-            new_image = image.composite(other_image, output_extension, &block)
-            image.path = new_image.path
-          end
-        end
-
-        def smush_it!
-          ::Spontaneous::Utils::SmushIt.smush!(image.path, current_image_format)
-        end
-
-        def optimize!
-          ImageOptimizer.run(image.path) if current_image_format == "jpg"
-        end
-
-        def border_radius(radius, bg_color = nil)
-          @image.format('png') if bg_color.nil? or bg_color == 'transparent'
-          puts @image.path
-          c = MiniMagick::CommandBuilder.new('convert')
-          c << @image.path
-          c.add_command(:format, "roundrectangle 0,0 %[fx:w-1],%[fx:h-1], 10,10")
-          c.add_command(:write, "info:tmp.mvg")
-          c << @image.path
-
-          puts c.command
-          # @image.run(c)
-          sub = Subexec.run(c.command, :timeout => MiniMagick.timeout)
-
-          c = MiniMagick::CommandBuilder.new('convert')
-
-          c << @image.path
-          # c.add_command(:write, "info:tmp.mvg")
-          c.add_command(:matte)
-          c.add_command(:bordercolor, "none")
-          c.add_command(:border, "0")
-          c.push('\\(')
-          c.push("+clone")
-          c.add_command(:alpha, 'transparent')
-          c.add_command(:background, 'white')
-          c.add_command(:fill, 'white')
-          c.add_command(:stroke, 'none')
-          c.add_command(:strokewidth, '0')
-          c.add_command(:draw, "@tmp.mvg")
-          c.push('\\)')
-          c.add_command(:compose, 'DstIn')
-          c.add_command(:composite)
-          c << @image.path
-          puts c.command
-          @image.run(c)
-
-        end
-
-
-        def __run__(process)
-          instance_eval(&process)
-        end
-
-        def method_missing(method, *args, &block)
-          params = args.map(&:to_s)
-          if image.respond_to?(method)
-            image.__send__(method, *params, &block)
-          else
-            image.method_missing(method, *params, &block)
-          end
-        end
-
-        def current_image_format
-          image[:format].downcase.gsub(/^jpeg$/, "jpg")
-        end
-      end
+    def page_lock_description
+      "Processing image '#{pending_value[:value][:filename]}'"
+    end
 
-      MAX_DIM = 2 ** ([42].pack('i').size * 8) - 1 unless defined?(MAX_DIM)
+    # original is special and should always be defined
+    def original
+      @original ||= sizes[:original]
+    end
 
-      attr_reader :path
+    def width
+      original.width
+    end
 
-      def initialize(media_file)
-        @media_file = media_file
-        @path = media_file.source
-      end
+    def height
+      original.height
+    end
 
-      def src
-        @media_file.url
-      end
+    def filesize
+      original.filesize
+    end
 
-      def filesize
-        ::File.size(path)
-      end
+    def src
+      original.src
+    end
 
-      def width
-        dimensions[0]
-      end
+    def filepath
+      unprocessed_value
+    end
 
-      def height
-        dimensions[1]
-      end
+    # formats are irrelevant to image/file fields
+    def outputs
+      [:original, :__ui__].concat(self.class.size_definitions.map { |name, process| name })
+    end
 
-      def dimensions
-        @dimensions ||= Spontaneous::ImageSize.read(path)
-      end
+    def value(format=:html, *args)
+      sizes[:original].src
+    end
 
-      def apply(process, name, tempfile)
-        image = ::MiniMagick::Image.open(path)
-        processor = ImageProcessor::ImageDelegator.new(image)
-        processor.__run__(process)
-        file = @media_file.rename(filename_for_size(name, image))
-        # copy the image into the tempfile provided by the parent #generate call
-        # this stops us from using a tempfile that is out of our control and can
-        # be closed before we're done
-        FileUtils.cp(image.path, tempfile.path)
-        file.copy(tempfile)
-
-        ImageProcessor.new(file)
-      end
+    def set_value!(value, process = true)
+      @sizes = nil
+      super
+    end
 
-      def filename_for_size(name, image)
-        original_filename = @media_file.filename
-        parts = original_filename.split('.')
-
-        # use the image format for the extension because tempfiles generated by
-        # mini_magick don't have extensions
-        # I hate the "jpeg" extension though
-        ext = image[:format].downcase.gsub(/^jpeg$/, "jpg")
-        base = parts[0..-2].join('.')
-        filename = [base, name, ext].join('.')
-        filename
-      end
+    def generate(name, media_file)
+      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)
+      size.generate
+    end
 
-      def serialize
-        {
-          :src => src,
-          :width => width,
-          :height => height,
-          :filesize => filesize,
-          :path => @media_file.path
-        }
-      end
 
-      def inspect
-        %(#<ImageProcessor:#{self.object_id} @media_file=#{@media_file.inspect}>)
-      end
+    def export(user = nil)
+      super(user).merge({
+        :processed_value => processed_values
+      })
     end
 
-
+    self.register(:image, :photo)
+  end
 end
+

data/lib/spontaneous/field/tags.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+  class Tags < Base
+    # Just use the standard String editor for now.
+    # TODO: This should be replaced with a tags specific one asap.
+    has_editor "Spontaneous.Field.String"
+
+    include Enumerable
+
+    def outputs
+      [:html, :tags]
+    end
+
+    def generate_html(value)
+      value
+    end
+
+    TAG_PARSER_RE = /"([^"]+)"|([^ ]+)/
+
+    def generate_tags(value)
+      return [] if value.blank?
+      (value).scan(TAG_PARSER_RE).flatten.compact
+    end
+
+    def taglist
+      values[:tags] || []
+    end
+
+    def each(&block)
+      taglist.each(&block)
+    end
+
+    self.register
+  end
+end

data/lib/spontaneous/field/update.rb

@@ -97,7 +97,7 @@ module Spontaneous::Field
       # updater are re-serialized.
       #
       def save
-        valid_fields = @fields.reject { |field| field.conflicted_update? }
+        valid_fields = @fields.reject { |field| field.invalid_update? || field.conflicted_update? }
         remove_update_lock(valid_fields)
         field_map = valid_fields.group_by { |f| f.owner }
         field_map.each do |owner, fields|

data/lib/spontaneous/field/webvideo/fallback.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Spontaneous::Field
+  class WebVideo
+    class Fallback < Provider
+      def self.id
+        "fallback"
+      end
+
+      def to_html(options = {})
+        params = player_attributes(options)
+        attributes = hash_to_attributes(params[:attr])
+        %(<iframe #{attributes}></iframe>)
+      end
+
+      def player_attributes(options = {})
+        o = player_options(options)
+
+        attributes = {
+          :type => "text/html",
+          :frameborder => "0",
+          :width => o.delete(:width),
+          :height => o.delete(:height)
+        }
+
+        make_query_options!(o)
+
+        attributes[:src] = @field.unprocessed_value
+
+        attributes.update(:webkitAllowFullScreen => "yes", :allowFullScreen => "yes") if o[:fullscreen]
+
+        {:tagname => "iframe", :tag => "<iframe/>", :attr => attributes}
+      end
+
+      def player_options(options = {})
+        default_player_options.merge(options)
+      end
+    end
+    Spontaneous::Field::WebVideo.provider Fallback
+  end
+end