radiant-paperclipped-extension 0.8.1

data/app/helpers/admin/assets_helper.rb

@@ -0,0 +1,5 @@
+module Admin::AssetsHelper
+  def automatic_size_descriptions
+    Asset.thumbnail_sizes.collect{|k,v| "#{k} (#{(v.to_s).match(/\d+x\d+/)})"}.join(', ')
+  end
+end

data/app/models/asset.rb

@@ -0,0 +1,279 @@
+require 'mime_type_ext'
+ 
+class Asset < ActiveRecord::Base
+  @@known_types = []
+  cattr_accessor :known_types
+ 
+  # type declaration machinery is consolidated here so that other extensions can add more types
+  # for example: Asset.register_type(:gps, %w{application/gpx+xml application/tcx+xml})
+  # the main Asset register_type() calls are in the class definition below after validation
+  
+  def self.register_type(type, mimes)
+    constname = type.to_s.upcase.to_sym
+    Mime.send(:remove_const, constname) if Mime.const_defined?(constname)
+    Mime::Type.register mimes.shift, type, mimes       # Mime::Type.register 'image/png', :image, %w[image/x-png image/jpeg image/pjpeg image/jpg image/gif]
+ 
+    self.class.send :define_method, "#{type}?".intern do |content_type|
+      Mime::Type.lookup_by_extension(type.to_s) == content_type.to_s
+    end
+  
+    define_method "#{type}?".intern do
+      self.class.send "#{type}?".intern, asset_content_type
+    end
+ 
+    self.class.send :define_method, "#{type}_condition".intern do
+      types = Mime::Type.lookup_by_extension(type.to_s).all_types
+      send(:sanitize_sql, ['asset_content_type IN (?)', types])
+    end
+ 
+    self.class.send :define_method, "not_#{type}_condition".intern do
+      types = Mime::Type.lookup_by_extension(type.to_s).all_types
+      send(:sanitize_sql, ['NOT asset_content_type IN (?)', types])
+    end
+  
+    named_scope type.to_s.pluralize.intern, :conditions => self.send("#{type}_condition".intern) do
+      def paged (options={})
+        paginate({:per_page => 20, :page => 1}.merge(options))
+      end
+    end
+ 
+    named_scope "not_#{type.to_s.pluralize}".intern, :conditions => self.send("not_#{type}_condition".intern) do
+      def paged (options={})
+        paginate({:per_page => 20, :page => 1}.merge(options))
+      end
+    end
+    
+    known_types.push(type)
+  end
+  
+  def self.known_type?(type)
+    known_types.include?(type)
+  end
+ 
+  # 'other' here means 'document', really: anything that is not image, audio or video.
+  
+  def other?
+    self.class.other?(asset_content_type)
+  end
+ 
+  def self.other?(content_type)
+    !self.mime_types_not_considered_other.include? content_type.to_s
+  end
+  
+  # the lambda delays interpolation, allowing extensions to affect the other_condition
+  named_scope :others, lambda {{:conditions => self.other_condition}}
+  known_types.push(:other)
+  
+  named_scope :newest_first, { :order => 'created_at DESC'}
+  
+  def self.other_condition
+    send(:sanitize_sql, ['asset_content_type NOT IN (?)', self.mime_types_not_considered_other])
+  end
+ 
+  def self.mime_types_not_considered_other
+    Mime::IMAGE.all_types + Mime::AUDIO.all_types + Mime::MOVIE.all_types  
+  end
+    
+  class << self
+    def search(search, filter, page)
+      unless search.blank?
+ 
+        search_cond_sql = []
+        search_cond_sql << 'LOWER(asset_file_name) LIKE (:term)'
+        search_cond_sql << 'LOWER(title) LIKE (:term)'
+        search_cond_sql << 'LOWER(caption) LIKE (:term)'
+ 
+        cond_sql = search_cond_sql.join(" or ")
+ 
+        @conditions = [cond_sql, {:term => "%#{search.downcase}%" }]
+      else
+        @conditions = []
+      end
+ 
+      options = { :conditions => @conditions,
+                  :order => 'created_at DESC',
+                  :page => page,
+                  :per_page => 10 }
+ 
+      @file_types = filter.blank? ? [] : filter.keys
+      if not @file_types.empty?
+        options[:total_entries] = count_by_conditions
+        Asset.paginate_by_content_types(@file_types, :all, options )
+      else
+        Asset.paginate(:all, options)
+      end
+    end
+ 
+    def find_all_by_content_types(types, *args)
+      with_content_types(types) { find *args }
+    end
+ 
+    def with_content_types(types, &block)
+      with_scope(:find => { :conditions => types_to_conditions(types).join(' OR ') }, &block)
+    end
+    
+    def count_by_conditions
+      type_conditions = @file_types.blank? ? nil : Asset.types_to_conditions(@file_types.dup).join(" OR ")
+      @count_by_conditions ||= @conditions.empty? ? Asset.count(:all, :conditions => type_conditions) : Asset.count(:all, :conditions => @conditions)
+    end
+    
+    def types_to_conditions(types)
+      types.collect! { |t| '(' + send("#{t}_condition") + ')' }
+    end
+    
+    def thumbnail_sizes
+      if Radiant::Config.table_exists? && Radiant::Config["assets.additional_thumbnails"]
+        thumbnails = additional_thumbnails
+      else
+        thumbnails = {}
+      end
+      thumbnails[:icon] = ['42x42#', :png]
+      thumbnails[:thumbnail] = ['100x100>', :png]
+      thumbnails
+    end
+ 
+    def thumbnail_names
+      thumbnail_sizes.keys
+    end
+    
+    # returns a descriptive list suitable for use as options in a select box
+    
+    def thumbnail_options
+      asset_sizes = thumbnail_sizes.collect{|k,v| 
+        size_id = k
+        size_description = "#{k}: "
+        size_description << (v.is_a?(Array) ? v.join(' as ') : v)
+        [size_description, size_id] 
+      }.sort_by{|pair| pair.last.to_s}
+      asset_sizes.unshift ['Original (as uploaded)', 'original']
+      asset_sizes
+    end
+    
+    # this is just a pointer that can be alias-chained in other extensions to add to or replace the list of thumbnail mechanisms
+    # its invocation is delayed with a lambda in has_attached_file so that it isn't called when the extension loads, but when an attachment initializes:
+    # that way we can be sure that all the related extensions have loaded and all the alias_chains are in place.
+    
+    def thumbnail_definitions
+      thumbnail_sizes
+    end
+ 
+  private
+    def additional_thumbnails
+      Radiant::Config["assets.additional_thumbnails"].gsub(' ','').split(',').collect{|s| s.split('=')}.inject({}) {|ha, (k, v)| ha[k.to_sym] = v; ha}
+    end
+  end
+  
+  # order_by 'title'
+ 
+  has_attached_file :asset,
+                    :processors => lambda {|instance| instance.choose_processors },   # this allows us to set processors per file type, and to add more in other extensions
+                    :styles => lambda { thumbnail_definitions },                      # and this lets extensions add thumbnailers (and also usefully defers the call)
+                    :whiny => false,
+                    :storage => Radiant::Config["assets.storage"] == "s3" ? :s3 : :filesystem, 
+                    :s3_credentials => {
+                      :access_key_id => Radiant::Config["assets.s3.key"],
+                      :secret_access_key => Radiant::Config["assets.s3.secret"]
+                    },
+                    :bucket => Radiant::Config["assets.s3.bucket"],
+                    :url => Radiant::Config["assets.url"] ? Radiant::Config["assets.url"] : "/:class/:id/:basename:no_original_style.:extension", 
+                    :path => Radiant::Config["assets.path"] ? Radiant::Config["assets.path"] : ":rails_root/public/:class/:id/:basename:no_original_style.:extension"
+                                 
+  has_many :page_attachments, :dependent => :destroy
+  has_many :pages, :through => :page_attachments
+ 
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  
+  validates_attachment_presence :asset
+  validates_attachment_content_type :asset, 
+    :content_type => Radiant::Config["assets.content_types"].gsub(' ','').split(',') if Radiant::Config.table_exists? && Radiant::Config["assets.content_types"] && Radiant::Config["assets.skip_filetype_validation"] == nil
+  validates_attachment_size :asset, 
+    :less_than => Radiant::Config["assets.max_asset_size"].to_i.megabytes if Radiant::Config.table_exists? && Radiant::Config["assets.max_asset_size"]
+    
+  before_save :assign_title
+  
+  register_type :image, %w[image/png image/x-png image/jpeg image/pjpeg image/jpg image/gif]
+  register_type :video, %w[video/mpeg video/mp4 video/ogg video/quicktime video/x-ms-wmv video/x-flv]
+  register_type :audio, %w[audio/mpeg audio/mpg audio/ogg application/ogg audio/x-ms-wma audio/vnd.rn-realaudio audio/x-wav]
+  register_type :swf, %w[application/x-shockwave-flash]
+  register_type :pdf, %w[application/pdf]
+ 
+  # alias for backwards-compatibility: movie can be video or swf
+  register_type :movie, Mime::SWF.all_types + Mime::VIDEO.all_types
+ 
+  def thumbnail(size='original')
+    return asset.url if size == 'original'
+    case 
+      when self.pdf?   : "/images/assets/pdf_#{size.to_s}.png"
+      when self.movie? : "/images/assets/movie_#{size.to_s}.png"
+      when self.video? : "/images/assets/movie_#{size.to_s}.png"
+      when self.swf? : "/images/assets/movie_#{size.to_s}.png" #TODO: special icon for swf-files
+      when self.audio? : "/images/assets/audio_#{size.to_s}.png"
+      when self.other? : "/images/assets/doc_#{size.to_s}.png"
+    else
+      self.asset.url(size.to_sym)
+    end
+  end
+  
+  def generate_style(name, args={}) 
+    size = args[:size] 
+    format = args[:format] || :jpg
+    asset = self.asset
+    unless asset.exists?(name.to_sym)
+      self.asset.styles[name.to_sym] = { :geometry => size, :format => format, :whiny => true, :convert_options => "", :processors => [:thumbnail] } 
+      self.asset.reprocess!
+    end
+  end
+  
+  # this has been added to support other extensions that want to add processors 
+  # eg paperclipped_gps uses gpsbabel in the same way as paperclipped uses imagemagick
+  # I also mean to add a video thumbnailer using ffmpeg 
+  
+  def choose_processors
+    [:thumbnail]
+  end
+ 
+  def basename
+    File.basename(asset_file_name, ".*") if asset_file_name
+  end
+  
+  def extension
+    asset_file_name.split('.').last.downcase if asset_file_name
+  end
+  
+  def dimensions(size='original')
+    @dimensions ||= {}
+    @dimensions[size] ||= supported_by_image_spec? && begin
+      image_spec = ImageSpec.new(filesystem_path(size))
+      [image_spec.width, image_spec.height]
+    rescue
+      [0, 0]
+    end
+  end
+  
+  def dimensions_known?
+    defined?(ImageSpec) && supported_by_image_spec?
+  end
+  
+  def width(size='original')
+    supported_by_image_spec? && self.dimensions(size)[0]
+  end
+  
+  def height(size='original')
+    supported_by_image_spec? && self.dimensions(size)[1]
+  end
+  
+  private
+    def filesystem_path(size='original')
+      "#{RAILS_ROOT}/public#{thumbnail(size)}"
+    end
+    
+    def supported_by_image_spec?
+      image? || swf?
+    end
+  
+    def assign_title
+      self.title = basename if title.blank?
+    end
+    
+end

data/app/models/asset_page_tags.rb

@@ -0,0 +1,101 @@
+module AssetPageTags
+  include Radiant::Taggable
+  include AssetTags
+
+  desc %{
+    Cycles through all assets attached to the current page.  
+    This tag does not require the title atttribute, nor do any of its children.
+    Use the @limit@ and @offset@ attribute to render a specific number of assets.
+    Use @by@ and @order@ attributes to control the order of assets.
+    Use @extensions@ attribute to specify which assets to be rendered.
+    
+    *Usage:* 
+    <pre><code><r:assets:each [limit=0] [offset=0] [order="asc|desc"] [by="position|title|..."] [extensions="png|pdf|doc"]>...</r:assets:each></code></pre>
+  }    
+  tag 'assets:each' do |tag|
+    options = tag.attr.dup
+    result = []
+    assets = tag.locals.page.assets.find(:all, assets_find_options(tag))
+    tag.locals.assets = assets
+    assets.each do |asset|
+      tag.locals.asset = asset
+      result << tag.expand
+    end
+    result
+  end
+  
+  desc %{
+    References the first asset attached to the current page.  
+    
+    *Usage:* 
+    <pre><code><r:assets:first>...</r:assets:first></code></pre>
+  }
+  tag 'assets:first' do |tag|
+    attachments = tag.locals.page.page_attachments
+    if first = attachments.first
+      tag.locals.asset = first.asset
+      tag.expand
+    end
+  end
+  
+  desc %{
+    Renders the contained elements only if the current asset is the first
+    asset attached to the current page.
+  
+    *Usage:*
+    <pre><code><r:if_first>...</r:if_first></code></pre>
+  }
+  tag 'assets:if_first' do |tag|
+    attachments = tag.locals.assets
+    asset = tag.locals.asset
+    if asset == attachments.first
+      tag.expand
+    end
+  end  
+  
+  
+  desc %{
+    Renders the contained elements only if the current asset is not the first
+    asset attached to the current page.
+    
+    *Usage:*
+    <pre><code><r:unless_first>...</r:unless_first></code></pre>
+  }
+  tag 'assets:unless_first' do |tag|
+    attachments = tag.locals.assets
+    asset = tag.locals.asset
+    if asset != attachments.first
+      tag.expand
+    end
+  end
+  
+  desc %{
+    Renders the contained elements only if the current contextual page has one or
+    more assets. The @min_count@ attribute specifies the minimum number of required
+    assets. You can also filter by extensions with the @extensions@ attribute.
+  
+    *Usage:*
+    <pre><code><r:if_assets [min_count="n"] [extensions="pdf|jpg"]>...</r:if_assets></code></pre>
+  }
+  tag 'if_assets' do |tag|
+    count = tag.attr['min_count'] && tag.attr['min_count'].to_i || 1
+    assets = tag.locals.page.assets.count(:conditions => assets_find_options(tag)[:conditions])
+    tag.expand if assets >= count
+  end
+  
+  desc %{
+    The opposite of @<r:if_assets/>@.
+  }
+  tag 'unless_assets' do |tag|
+    count = tag.attr['min_count'] && tag.attr['min_count'].to_i || 1
+    assets = tag.locals.page.assets.count(:conditions => assets_find_options(tag)[:conditions])
+    tag.expand unless assets >= count
+  end
+  
+  # Resets the page Url and title within the asset tag
+  [:title, :url].each do |method|
+    tag "assets:page:#{method.to_s}" do |tag|
+      tag.locals.page.send(method)
+    end
+  end
+end

data/app/models/asset_tags.rb

@@ -0,0 +1,272 @@
+module AssetTags
+  include Radiant::Taggable
+  
+  class TagError < StandardError; end
+  
+  desc %{
+    The namespace for referencing images and assets. You may specify the @title@
+    attribute on this tag for all contained tags to refer to that asset.  
+    
+    *Usage:* 
+    <pre><code><r:assets [title="asset_title"]>...</r:assets></code></pre>
+  }    
+  tag 'assets' do |tag|
+    tag.locals.asset = Asset.find_by_title(tag.attr['title']) || Asset.find(tag.attr['id']) unless tag.attr.empty?
+    tag.expand
+  end
+
+  desc %{
+    Renders the value for a top padding for the image. Put the image in a
+    container with specified height and using this tag you can vertically
+    align the image within it's container.
+  
+    *Usage*:
+    <pre><code><r:assets:top_padding container = "140" [size="icon"]/></code></pre>
+  
+    *Working Example*:
+    <pre><code>
+      <ul>
+        <r:assets:each>
+          <li style="height:140px">
+            <img style="padding-top:<r:top_padding size='category' container='140' />px" 
+                 src="<r:url />" alt="<r:title />" />
+          </li>
+        </r:assets:each>
+      </ul>
+    </code></pre>
+  }
+  tag 'assets:top_padding' do |tag|
+    asset, options = asset_and_options(tag)
+    raise TagError, 'Asset is not an image' unless asset.image?
+    raise TagError, "'container' attribute required" unless options['container']
+    size = options['size'] ? options.delete('size') : 'icon'
+    container = options.delete('container')
+    img_height = asset.height(size)
+    (container.to_i - img_height.to_i)/2
+  end
+  
+  ['height','width'].each do |dimension|
+    desc %{
+      Renders the #{dimension} of the asset.
+    }
+    tag "assets:#{dimension}" do |tag|
+      asset, options = asset_and_options(tag)
+      unless asset.dimensions_known?
+        raise TagError, "Can't determine #{dimension} for this Asset. It may not be a supported type."
+      end
+      size = options['size'] ? options.delete('size') : 'original'
+      asset.send(dimension, size)
+    end
+  end
+
+  desc %{
+    Renders the containing elements only if the asset's content type matches
+    the regular expression given in the @matches@ attribute. If the
+    @ignore_case@ attribute is set to false, the match is case sensitive. By
+    default, @ignore_case@ is set to true.
+      
+    The @title@ attribute is required on the parent tag unless this tag is used in @assets:each@.
+
+    *Usage:* 
+    <pre><code><r:assets:each><r:if_content_type matches="regexp" [ignore_case=true|false"]>...</r:if_content_type></r:assets:each></code></pre>
+  }
+  tag 'assets:if_content_type' do |tag|
+    options = tag.attr.dup
+    # XXX build_regexp_for comes from StandardTags
+    # XXX its cool if I use it, right?
+    regexp = build_regexp_for(tag,options)
+    asset_content_type = tag.locals.asset.asset_content_type
+    tag.expand unless asset_content_type.match(regexp).nil?
+  end
+  
+  #TODO: could use better docs for Asset#other? case explaining what types it covers
+  Asset.known_types.each do |known_type|
+    desc %{
+      Renders the contents only of the asset is of the type #{known_type}
+    }
+    tag "assets:if_#{known_type}" do |tag|
+      tag.expand if find_asset(tag, tag.attr.dup).send("#{known_type}?".to_sym)
+    end
+
+    desc %{
+      Renders the contents only of the asset is not of the type #{known_type}
+    }
+    tag "assets:unless_#{known_type}" do |tag|
+      tag.expand unless find_asset(tag, tag.attr.dup).send("#{known_type}?".to_sym)
+    end
+  end
+  
+  [:title, :caption, :asset_file_name, :asset_content_type, :asset_file_size, :id].each do |method|
+    desc %{
+      Renders the @#{method.to_s}@ attribute of the asset
+    }
+    tag "assets:#{method.to_s}" do |tag|
+      asset, options = asset_and_options(tag)
+      asset.send(method) rescue nil
+    end
+  end
+  
+  tag 'assets:filename' do |tag|
+    asset, options = asset_and_options(tag)
+    asset.asset_file_name rescue nil
+  end
+  
+  desc %{
+    Renders an image tag for the asset.
+    
+    Using the optional @size@ attribute, different sizes can be display.
+    “thumbnail” and “icon” sizes are built in, but custom ones can be set
+    using by changing assets.addition_thumbnails in the Radiant::Config
+    settings.
+    
+    *Usage:* 
+    <pre><code><r:assets:image [title="asset_title"] [size="icon|thumbnail"]></code></pre>
+  }    
+  tag 'assets:image' do |tag|
+    asset, options = asset_and_options(tag)
+    raise TagError, 'Asset is not an image' unless asset.image?
+    size = options['size'] ? options.delete('size') : 'original'
+    geometry = options['geometry'] ? options.delete('geometry') : nil
+    #This is very experimental and will generate new sizes on the fly
+    asset.generate_style(size, { :size => geometry }) if geometry
+    
+    alt = " alt='#{asset.title}'" unless tag.attr['alt'] rescue nil
+    attributes = options.inject('') { |s, (k, v)| s << %{#{k.downcase}="#{v}" } }.strip
+    attributes << alt unless alt.nil?
+    url = asset.thumbnail(size)
+    %{<img src="#{url}" #{attributes unless attributes.empty?} />} rescue nil
+  end
+  
+  desc %{
+    Embeds a flash-movie in a cross-browser-compatible fashion using only HTML
+    If no width and height attributes are given it will use the intrinsic
+    dimensions of the swf file
+    
+    *Usage:*
+    <pre><code><r:assets:flash [title="asset_title"] [width="100"] [height="100"]>Fallback content</flash></code></pre>
+    
+    *Example with text fallback:*
+    <pre><code><r:assets:flash title="flash_movie">
+        Sorry, you need to have flash installed, <a href="http://adobe.com/flash">get it here</a>
+    </flash></code></pre>
+    
+    *Example with image fallback and explicit dimensions:*
+    <pre><code><r:assets:flash title="flash_movie" width="300" height="200">
+        <r:assets:image title="flash_screenshot" />
+      </flash></code></pre>
+  }
+  tag 'assets:flash' do |tag|
+    asset, options = asset_and_options(tag)
+    raise TagError, 'Must be flash' unless asset.swf?
+    url = asset.thumbnail('original')
+    dimensions = [(tag.attr['width'] || asset.width),(tag.attr['height'] || asset.height)]
+    swf_embed_markup url, dimensions, tag.expand
+  end
+  
+  tag 'assets:thumbnail' do |tag|
+    asset, options = asset_and_options(tag)
+    asset.generate_thumbnail('test', ['24x24#',nil])
+    asset.save    
+  end
+  
+  desc %{
+    Renders the url for the asset. If the asset is an image, the <code>size</code> attribute can be used to 
+    generate the url for that size. 
+    
+    *Usage:* 
+    <pre><code><r:url [title="asset_title"] [size="icon|thumbnail"]></code></pre>
+  }    
+  tag 'assets:url' do |tag|
+    asset, options = asset_and_options(tag)
+    size = options['size'] ? options.delete('size') : 'original'
+    asset.thumbnail(size) rescue nil
+  end
+  
+  desc %{
+    Renders a link to the asset. If the asset is an image, the <code>size</code> attribute can be used to 
+    generate a link to that size. 
+    
+    *Usage:* 
+    <pre><code><r:assets:link [title="asset_title"] [size="icon|thumbnail"] /></code></pre>
+  }
+  tag 'assets:link' do |tag|
+    asset, options = asset_and_options(tag)
+    size = options['size'] ? options.delete('size') : 'original'
+    text = options['text'] || asset.title
+    anchor = options['anchor'] ? "##{options.delete('anchor')}" : ''
+    attributes = options.inject('') { |s, (k, v)| s << %{#{k.downcase}="#{v}" } }.strip
+    attributes = " #{attributes}" unless attributes.empty?
+    text = tag.double? ? tag.expand : text
+    url = asset.thumbnail(size)
+    %{<a href="#{url  }#{anchor}"#{attributes}>#{text}</a>} rescue nil
+  end
+  
+  desc %{
+  Renders the extension of the asset, as extracted from its filename.
+  
+  *Usage*:
+    <pre><code>
+      <ul>
+        <r:assets:each extensions="doc|pdf">
+          <li class="<r:extension/>">
+            <r:link/>
+          </li>
+        </r:assets:each>
+      </ul>
+    </code></pre>
+  }
+  tag 'assets:extension' do |tag|
+    raise TagError, 'must be nested inside an assets or assets:each tag' unless tag.locals.asset
+    asset = tag.locals.asset
+    asset.asset_file_name[/\.(\w+)$/, 1]
+  end
+  
+  private
+    def asset_and_options(tag)
+      options = tag.attr.dup
+      [find_asset(tag, options), options]
+    end
+    
+    def find_asset(tag, options)
+      raise TagError, "'title' attribute required" unless title = options.delete('title') or id = options.delete('id') or tag.locals.asset
+      tag.locals.asset || Asset.find_by_title(title) || Asset.find(id)
+    end
+    
+    def assets_find_options(tag)
+      attr = tag.attr.symbolize_keys
+      extensions = attr[:extensions] && attr[:extensions].split('|') || []
+      conditions = unless extensions.blank?
+        [ extensions.map { |ext| "assets.asset_file_name LIKE ?"}.join(' OR '), 
+          *extensions.map { |ext| "%.#{ext}" } ]
+      else
+        nil
+      end
+      
+      by = attr[:by] || 'page_attachments.position'
+      order = attr[:order] || 'asc'
+      
+      options = {
+        :order => "#{by} #{order}",
+        :limit => attr[:limit] || nil,
+        :offset => attr[:offset] || nil,
+        :conditions => conditions
+      }
+    end
+    
+    def swf_embed_markup(url, dimensions, fallback_content)
+      width, height = dimensions
+      %{<!--[if !IE]> -->
+        <object type="application/x-shockwave-flash" data="#{url}" width="#{width}" height="#{height}">
+      <!-- <![endif]-->
+      <!--[if IE]>
+        <object width="#{width}" height="#{height}"
+          classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
+          codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0">
+          <param name="movie" value="#{url}" />
+      <!-->
+      #{fallback_content}
+        </object>
+      <!-- <![endif]-->}
+    end
+end
+