radiant 0.9.1 → 1.0.0.rc1

data/vendor/extensions/assets/Rakefile

@@ -0,0 +1,111 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "radiant-assets-extension"
+    gem.summary = %Q{Assets extension for Radiant CMS}
+    gem.description = %Q{Assets extension based Keith Bingman's excellent Paperclipped extension.}
+    gem.email = "me@johnwlong.com"
+    gem.homepage = "https://github.com/radiant/radiant-assets-extension"
+    gem.authors = ["Keith Bingman", "Benny Degezelle", "William Ross", "John W. Long"]
+    gem.add_dependency 'radiant', ">= 0.9.1"
+    gem.add_dependency 'paperclip', "~> 2.3.3"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. This is only required if you plan to package copy_move as a gem."
+end
+# I think this is the one that should be moved to the extension Rakefile template
+
+# In rails 1.2, plugins aren't available in the path until they're loaded.
+# Check to see if the rspec plugin is installed first and require
+# it if it is.  If not, use the gem version.
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'boot')
+require 'rake'
+require 'rake/rdoctask'
+
+rspec_base = File.expand_path(File.dirname(__FILE__) + '/../../radiant/vendor/plugins/rspec/lib')
+$LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base)
+require 'spec/rake/spectask'
+# require 'spec/translator'
+
+extension_root = File.expand_path(File.dirname(__FILE__))
+
+task :default => :spec
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec', '--rails']
+  end
+  
+  desc "Print Specdoc for all specs"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  [:models, :controllers, :views, :helpers].each do |sub|
+    desc "Run the specs under spec/#{sub}"
+    Spec::Rake::SpecTask.new(sub) do |t|
+      t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+      t.spec_files = FileList["spec/#{sub}/**/*_spec.rb"]
+    end
+  end
+  
+  # Hopefully no one has written their extensions in pre-0.9 style
+  # desc "Translate specs from pre-0.9 to 0.9 style"
+  # task :translate do
+  #   translator = ::Spec::Translator.new
+  #   dir = RAILS_ROOT + '/spec'
+  #   translator.translate(dir, dir)
+  # end
+
+  # Setup specs for stats
+  task :statsetup do
+    require 'code_statistics'
+    ::STATS_DIRECTORIES << %w(Model\ specs spec/models)
+    ::STATS_DIRECTORIES << %w(View\ specs spec/views)
+    ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers)
+    ::STATS_DIRECTORIES << %w(Helper\ specs spec/views)
+    ::CodeStatistics::TEST_TYPES << "Model specs"
+    ::CodeStatistics::TEST_TYPES << "View specs"
+    ::CodeStatistics::TEST_TYPES << "Controller specs"
+    ::CodeStatistics::TEST_TYPES << "Helper specs"
+    ::STATS_DIRECTORIES.delete_if {|a| a[0] =~ /test/}
+  end
+
+  namespace :db do
+    namespace :fixtures do
+      desc "Load fixtures (from spec/fixtures) into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+      task :load => :environment do
+        require 'active_record/fixtures'
+        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'spec', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+          Fixtures.create_fixtures('spec/fixtures', File.basename(fixture_file, '.*'))
+        end
+      end
+    end
+  end
+end
+
+desc 'Generate documentation for the assets extension.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PaperclippedExtension'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Load any custom rakefiles for extension
+Dir[File.dirname(__FILE__) + '/tasks/*.rake'].sort.each { |f| require f }

data/vendor/extensions/assets/VERSION

@@ -0,0 +1 @@
+1.0.0.rc1

data/vendor/extensions/assets/app/controllers/admin/assets_controller.rb

@@ -0,0 +1,54 @@
+class Admin::AssetsController < Admin::ResourceController
+  paginate_models(:per_page => 50)
+  
+  def index
+    assets = Asset.scoped({:order => "created_at DESC"})
+    
+    @term = params[:search] || ''
+    assets = assets.matching(@term) if @term && !@term.blank?
+    
+    @types = params[:filter] || []
+    if @types.include?('all')
+      params[:filter] = nil
+    elsif @types.any?
+      assets = assets.of_types(@types)
+    end
+    
+    @assets = paginated? ? assets.paginate(pagination_parameters) : assets.all
+    respond_to do |format|
+      format.html { render }
+      format.js { 
+        @page = Page.find_by_id(params[:page_id])
+        render :partial => 'asset_table', :locals => {:with_pagination => !!@page}
+      }
+    end
+  end
+  
+  def create
+    @asset.update_attributes!(params[:asset])
+    if params[:for_attachment]
+      @page_attachment = @asset.page_attachments.build(:page_id => params[:page_id])
+      render :partial => 'admin/page_attachments/new_attachment'
+    else 
+      response_for :create
+    end
+  end
+  
+  # Refreshes the paperclip thumbnails
+  def refresh
+    unless params[:id]
+      @assets = Asset.find(:all)
+      @assets.each do |asset|
+        asset.asset.reprocess!
+      end
+      flash[:notice] = t('assets_extension.thumbnails_refreshed')
+      redirect_to admin_assets_path
+    else
+      @asset = Asset.find(params[:id])
+      @asset.asset.reprocess!
+      flash[:notice] = t('assets_extension.thumbnails_refreshed')
+      redirect_to edit_admin_asset_path(@asset)
+    end
+  end
+  
+end

data/vendor/extensions/assets/app/controllers/admin/page_attachments_controller.rb

@@ -0,0 +1,45 @@
+class Admin::PageAttachmentsController < Admin::ResourceController
+  helper 'admin/assets'
+  
+  def new
+    if params[:asset_ids] && params[:asset_ids].any?            
+      @page_attachments = params[:asset_ids].collect{ |aid| @page.page_attachments.build(:asset_id => aid) }
+      render :partial => 'admin/page_attachments/new_attachment', :collection => @page_attachments
+    else
+      render :partial => 'admin/page_attachments/new_attachment', :object => @page_attachment
+    end
+  end
+  
+  def create
+    @page_attachment.update_attributes!(params[:page_attachment])
+    @page = @page_attachment.page
+    render :partial => 'admin/page_attachments/attachment_list' 
+  end
+  
+  def destroy
+    @page = @page_attachment.page
+    @page_attachment.destroy
+    render :partial => 'admin/page_attachments/attachment_list' 
+  end
+  
+  def load_model
+    @page = Page.find_by_id(params[:page_id]) || Page.new
+    self.model = if params[:id]
+      @page.page_attachments.find(params[:id])
+    elsif params[:asset_id]
+      @page.page_attachments.build(:asset_id => params[:asset_id])
+    end
+  end
+  
+  # Saves (presumably revised) attachment order.
+  def reorder
+    params[:page_attachments].each_with_index do |id,idx| 
+      page_attachment = PageAttachment.find(id)
+      page_attachment.position = idx+1
+      page_attachment.save
+    end
+    clear_model_cache
+    render :nothing => true
+  end
+
+end

data/vendor/extensions/assets/app/helpers/admin/assets_helper.rb

@@ -0,0 +1,11 @@
+module Admin::AssetsHelper
+  
+  def automatic_size_descriptions
+    Asset.thumbnail_sizes.collect{|k,v| "#{k} (#{(v.to_s).match(/\d+x\d+/)})"}.join(', ')
+  end
+  
+  def asset_insertion_link(asset)
+    link_to t('assets_extension.insert'), '#', :class => 'insert_asset', :rel => asset.insertion_rel
+  end
+  
+end

data/vendor/extensions/assets/app/models/asset.rb

@@ -0,0 +1,161 @@
+class Asset < ActiveRecord::Base
+
+  has_many :page_attachments, :dependent => :destroy
+  has_many :pages, :through => :page_attachments
+  has_site if respond_to? :has_site
+
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  
+  default_scope :order => "created_at DESC"
+  
+  named_scope :latest, lambda { |limit|
+    { :order => "created_at DESC", :limit => limit }
+  }
+
+  named_scope :of_types, lambda { |types|
+    mimes = AssetType.slice(*types).map(&:mime_types).flatten
+    { :conditions => ["asset_content_type IN (#{mimes.map{'?'}.join(',')})", *mimes] }
+  }
+
+  named_scope :matching, lambda { |term| 
+    { :conditions => ["LOWER(assets.asset_file_name) LIKE (:term) OR LOWER(title) LIKE (:term) OR LOWER(caption) LIKE (:term)", {:term => "%#{term.downcase}%" }] }
+  }
+
+  named_scope :except, lambda { |assets| 
+    if assets.any?
+      assets = assets.split(',') if assets.is_a?(String)
+      asset_ids = assets.first.is_a?(Asset) ? assets.map(&:id) : assets
+      { :conditions => ["assets.id NOT IN(#{asset_ids.map{ '?' }.join(',')})", *asset_ids] }
+    else
+      {}
+    end
+  }
+    
+  has_attached_file :asset,
+                    :styles => lambda { |attachment|
+                      AssetType.from(attachment.instance_read(:content_type)).paperclip_styles
+                    },
+                    :processors => lambda { |asset|
+                      asset.paperclip_processors
+                    },
+                    :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"]
+                    },
+                    :s3_host_alias => Radiant.config["assets.s3.host_alias"] || Radiant.config["assets.s3.bucket"],
+                    :bucket => Radiant.config["assets.s3.bucket"],
+                    :url => Radiant.config["assets.url"],
+                    :path => Radiant.config["assets.path"]
+
+  before_save :assign_title
+  before_save :assign_uuid
+                                 
+  validates_attachment_presence :asset, :message => "You must choose a file to upload!"
+  if Radiant.config["assets.skip_filetype_validation"] != "true" && Radiant.config['assets.content_types']
+    validates_attachment_content_type :asset, :content_type => Radiant.config["assets.content_types"].gsub(' ','').split(',')
+  end
+  validates_attachment_size :asset, :less_than => ( Radiant.config["assets.max_asset_size"] || 5 ).to_i.megabytes
+
+  def asset_type
+    AssetType.from(asset.content_type)
+  end
+  delegate :paperclip_processors, :paperclip_styles, :style_dimensions, :style_format, :to => :asset_type
+
+  def thumbnail(style_name='original')
+    return asset.url if style_name.to_sym == :original
+    return asset.url(style_name.to_sym) if has_style?(style_name)
+    return asset_type.icon(style_name)
+  end
+
+  def has_style?(style_name)
+    paperclip_styles.keys.include?(style_name.to_sym)
+  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 attached_to?(page)
+    pages.include?(page)
+  end
+  
+  # geometry methods will return here
+  # if they can be made more S3-friendly
+
+  # this is used to pass insertion guidance to javascript
+  def insertion_rel
+    radius_tag = asset_type.default_radius_tag || 'link';
+    size = Radiant.config['assets.insertion_size']
+    "#{radius_tag}_#{size}_#{id}"
+  end
+
+
+private
+
+  def assign_title
+    self.title = basename if title.blank?
+  end
+  
+  def assign_uuid
+    self.uuid = UUIDTools::UUID.timestamp_create.to_s if uuid.blank?
+  end
+  
+  class << self
+    def known_types
+      AssetType.known_types
+    end
+    
+    # searching and pagination moved to the controller
+
+    def find_all_by_asset_types(asset_types, *args)
+      with_asset_types(asset_types) { find *args }
+    end
+
+    def count_with_asset_types(asset_types, *args)
+      with_asset_types(asset_types) { count *args }
+    end
+
+    def with_asset_types(asset_types, &block)
+      with_scope(:find => { :conditions => AssetType.conditions_for(asset_types) }, &block)
+    end
+  end
+
+  # called from AssetType to set type_condition? methods on Asset
+  def self.define_class_method(name, &block)
+    eigenclass.send :define_method, name, &block
+  end
+
+  # returns the return value of class << self block, which is self (as defined within that block)
+  def self.eigenclass
+    class << self; self; end
+  end
+
+  # for backwards compatibility
+  def self.thumbnail_sizes
+    AssetType.find(:image).paperclip_styles
+  end
+
+  def self.thumbnail_names
+    thumbnail_sizes.keys
+  end
+
+  # this is a convenience for image-pickers
+  def self.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
+  
+end

data/vendor/extensions/assets/app/models/asset_tags.rb

@@ -0,0 +1,378 @@
+module AssetTags
+  include Radiant::Taggable
+  include TagDeprecation
+  
+  class TagError < StandardError; end
+  
+  %w{top_padding width height caption asset_file_name asset_content_type asset_file_size id filename image flash thumbnail url link extension if_content_type page:title page:url}.each do |name|
+    deprecated_tag "assets:#{name}", :substitute => "asset:#{name}", :deadline => '2.0'
+  end
+  
+  Asset.known_types.each do |known_type|
+    deprecated_tag "assets:if_#{known_type}", :substitute => "asset:if_#{known_type}", :deadline => '2.0'
+    deprecated_tag "assets:unless_#{known_type}", :substitute => "asset:unless_#{known_type}", :deadline => '2.0'
+  end
+  
+  desc %{
+    The namespace for referencing images and assets.
+    
+    *Usage:* 
+    <pre><code><r:asset [title="asset_title"]>...</r:asset></code></pre>
+  }    
+  tag 'asset' do |tag|
+    tag.locals.asset = find_asset unless tag.attr.empty?
+    tag.expand
+  end
+
+  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' do |tag|
+    tag.expand
+  end
+  tag 'assets:each' do |tag|
+    options = tag.attr.dup
+    result = []
+    tag.locals.assets = tag.locals.page.assets.scoped(assets_find_options(tag))
+    tag.render('asset_list', tag.attr.dup, &tag.block)
+  end
+
+  # General purpose paginated asset lister. Very useful dryness.
+  # Tag.locals.assets must be defined but can be empty.
+
+  tag 'asset_list' do |tag|
+    raise TagError, "r:asset_list: no assets to list" unless tag.locals.assets
+    options = tag.attr.symbolize_keys
+    result = []
+    pagination = pagination_control(tag)
+    assets = pagination ? tag.locals.assets.paginate(pagination) : tag.locals.assets.all
+    assets.each do |asset|
+      tag.locals.asset = asset
+      result << tag.expand
+    end
+    if pagination && assets.total_pages > 1
+      tag.locals.paginated_list = assets
+      result << tag.render('pagination')
+    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|
+    if tag.locals.asset = tag.locals.page.assets.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"]>...</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 "asset:page:#{method.to_s}" do |tag|
+      tag.locals.page.send(method)
+    end
+  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:asset:top_padding container = "140" [size="icon"]/></code></pre>
+  
+    *Working Example*:
+    <pre><code>
+      <ul>
+        <r:asset: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:asset:each>
+      </ul>
+    </code></pre>
+  }
+  tag 'asset: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 "asset:#{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 @asset:each@.
+
+    *Usage:* 
+    <pre><code><r:asset:each><r:if_content_type matches="regexp" [ignore_case=true|false"]>...</r:if_content_type></r:asset:each></code></pre>
+  }
+  tag 'asset: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 "asset: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 "asset: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 "asset:#{method.to_s}" do |tag|
+      asset, options = asset_and_options(tag)
+      asset.send(method) rescue nil
+    end
+  end
+  
+  tag 'asset: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:asset:image [title="asset_title"] [size="icon|thumbnail"]></code></pre>
+  }    
+  tag 'asset:image' do |tag|
+    tag.locals.asset, options = asset_and_options(tag)
+    raise TagError, 'Asset is not an image' unless tag.locals.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 = tag.locals.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:asset:flash [title="asset_title"] [width="100"] [height="100"]>Fallback content</flash></code></pre>
+    
+    *Example with text fallback:*
+    <pre><code><r:asset: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:asset:flash title="flash_movie" width="300" height="200">
+        <r:asset:image title="flash_screenshot" />
+      </flash></code></pre>
+  }
+  tag 'asset: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 'asset: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 'asset: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:asset:link [title="asset_title"] [size="icon|thumbnail"] /></code></pre>
+  }
+  tag 'asset: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>
+          <li class="<r:extension/>">
+            <r:link/>
+          </li>
+        </r:assets:each>
+      </ul>
+    </code></pre>
+  }
+  tag 'asset: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)
+    return tag.locals.asset if tag.locals.asset
+    if title = options.delete('name') || options.delete('title')
+      Rails.logger.warn "<<< finding asset by title #{title}"
+      Asset.find_by_title(title)
+    elsif id = options.delete('id')
+      Rails.logger.warn "<<< finding asset by id #{id}"
+      Asset.find_by_id(id)
+    else
+      raise TagError, "'name' or 'id' attribute required for unenclosed r:asset tag" unless tag.locals.asset
+    end
+  end
+  
+  def assets_find_options(tag)
+    attr = tag.attr.symbolize_keys
+    extensions = attr[:extensions] && attr[:extensions].split('|') || []
+    conditions = unless extensions.blank?
+      # this is soon to be removed in favour of asset types
+      [ 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
+