radiant-clipped-extension-add-group 1.1.2

data/LICENSE

@@ -0,0 +1,22 @@
+== MIT License
+
+Copyright (c) 2011 Keith Bingman, Benny Degezelle, William Ross, and John W. Long
+Copyright (c) 2008-2010, Keith Bingman
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# Radiant Clipped Extension
+
+[![Build Status](https://secure.travis-ci.org/radiant/radiant-clipped-extension.png)](http://travis-ci.org/radiant/radiant-clipped-extension)
+
+Asset management for Radiant CMS.
+
+The Clipped extension comes bundled with the Radiant gem but may be updated separately. Only Radiant versions 1.0 or newer are supported.
+
+Please file bugs and feature requests on [Github][issues]. If you have questions regarding usage ask on the [mailing list][mailing-list].
+
+[issues]: https://github.com/radiant/radiant-clipped-extension/issues
+[mailing-list]: https://groups.google.com/forum/?hl=en#!forum/radiantcms
+
+## Features
+
+* Concurrent uploads
+* Automatic thumbnail generation
+  * requiers ImageMagick for images
+  * requiers FFmpeg for videos
+  * requiers Ghostscript for PDFs
+* In-page and dedicated management interfaces
+* Easily to extended with new asset types and processors
+
+## Installation
+
+If you installed the Radiant gem then you already have Clipped installed. You can upgrade to a newer version using `bundle update radiant-clipped-extension`.
+
+Installation of the optional post-processors varies by system but are likely available through your package manager.
+
+### Mac OSX
+
+    brew install ghostscript imagemagick ffmpeg
+    # or
+    port install ghostscript imagemagick ffmpeg
+
+### Debian
+
+    apt-get install ghostscript imagemagick ffmpeg
+
+### Windows
+
+[Ghostscript][ghostscript], [ImageMagick][imagemagick] and [FFmpeg][ffmpeg] all
+offer Windows installers that you can install in the usual way.
+
+[ghostscript]: http://sourceforge.net/projects/ghostscript/
+[imagemagick]: http://www.imagemagick.org/script/binary-releases.php
+[ffmpeg]: http://ffmpeg.zeranoe.com/builds/
+
+If the post-processors are not in your `PATH` or you're running Passenger you might need to set `Paperclip.options[:command_path]` to the location where the binaries are installed.
+
+## Configuration
+
+The clipped extension is configured in the usual way, but only its minor settings are exposed in the admin interface. The more architectural settings shouldn't be changed at runtime and some of them will require a lot of sorting out if they're changed at all, so those are only accessible through the console or by editing the database. Eventually they will be made part of the initial radiant installation process.
+
+### Structural settings
+
+* `paperclip.url` sets the url scheme for attached files. Paperclip interpolations are applied. You probably don't want to change this.
+* `paperclip.path` sets the path scheme for attached files. Paperclip interpolations are applied. You might conceivably want to change this.
+* `paperclip.additional_thumbnails` is a string of comma-separated style definitions that is passed to paperclip for any asset type that has a post-processor (that is, currently, images, pdfs and video clips). The definitions are in the format name=geometry and when assembled the string will look something like `preview=640x640>,square=#260x260`. Thumbnail and icon styles are already defined and don't need to be configured this way.
+* `paperclip.storage` can be 'filesystem' (the default) or 'fog' for cloud storage (such as s3).
+* `paperclip.skip_filetype_validation` is true by default and allows uploads of any mime type.
+
+### Cloud Storage
+
+Set `paperclip.storage` to 'fog' and add the following line to your `Gemfile`
+
+`gem "fog", "~> 1.0"`
+
+You also have to provide the following settings:
+
+* `paperclip.fog.provider` # set to one of "AWS", "Google" or "Rackspace"
+
+If set to AWS, provide the following:
+
+* `paperclip.s3.bucket`
+* `paperclip.s3.key`
+* `paperclip.s3.secret`
+* `paperclip.s3.region`
+
+If set to "Google", provide the following:
+
+* `paperclip.fog.directory`
+* `paperclip.google_storage.access_key_id`
+* `paperclip.google_storage.secret_access_key`
+
+If set to "Rackspace", provide the following:
+
+* `paperclip.fog.directory`
+* `paperclip.rackspace.username`
+* `paperclip.rackspace.api_key`
+
+And optionally:
+
+* `paperclip.fog.host`
+* `paperclip.fog.public?`
+
+### Configurable settings
+
+If you want to disable a whole category of post-processing, set one of these options to false:
+
+* `assets.create_image_thumbnails?`
+* `assets.create_video_thumbnails?`
+* `assets.create_pdf_thumbnails?`
+
+If we can't find ffmpeg on initialization, video thumbnailing will be disabled automatically by setting `assets.create_video_thumbnails?` to false.
+
+To set a threshold for the size of uploads permitted:
+
+* `assets.max_asset_size` which should be an integer number of MB
+
+And you can set some defaults:
+
+* `assets.insertion_size` is the name of the style that's used when you click on 'insert' to add a radius asset tag to your text. You can edit it after insertion, of course.
+* `assets.display_size` is the name of the style that's shows when you edit a single asset in the admin interface.
+
+## Usage
+
+For most purposes you will probably work with assets while you're working on pages. Click on one of the 'assets' links and a panel will pop up allowing you to find, insert and attach existing assets or upload new ones.
+
+For tidying up, replacing files and other admin, click on the 'assets' tab to get a larger version of the same list. Here again you can search for assets and filter the results by type, but the options are 'edit' and 'remove' and on editing you can change name, file and caption while keeping page associations intact.
+
+## Radius Tags
+
+The asset manager has its own family of radius tags. The basic tag is `<r:asset/>`, which can be used either alone or as a double tag. This tag requires a `name` or `id` attribute, which references the asset. The `<r:asset/>` tag can be combined with other tags for a variety of uses:
+
+    <r:asset:image name="image.png"/>  #=>  <img src="/path/to/image.png" />
+    <r:asset:link name="image.png"/>   #=>  <a href="/path/to/image.png">image.png</a>
+
+You could also use:
+
+    <r:asset:link name="bar.pdf">Download PDF</r:asset:link>
+
+Asset links are also available, such as content_type, file_size, and url.
+
+Another important tag is the `<r:assets:each>...</r:assets:each>` (note the plural namespace tag "assets"). If a page has attached assets, the `<r:assets:each>` tag will cycle through each asset. You can then use an image, `link` or `url` tag to display and connect your assets. Usage:
+
+    <r:assets:each [limit=0] [offset=0] [order="asc|desc"] [by="position|title|..."]>
+      ...
+    </r:assets:each>
+
+This tag uses the following parameters:
+
+* `limit` and `offset` let you specify a range of assets
+* `order` and `by` lets you control sorting
+
+The conditional tags `<r:if_assets [min_count="0"]>` and `<r:unless_assets [min_count="0"]>` allow you to optionally render content based on the existence of tags. They accept the same options as `<r:assets:each>`.
+
+Thumbnails are automatically generated for images when the images are uploaded. By default, two sizes are made for use within the extension itself. These are "icon" 42px by 42px and "thumbnail" which is 100px square.
+
+You can access sizes of image assets for various versions with tags like `<r:asset:width [size="original"]/>` and `<r:asset:height [size="original"]/>`.
+
+Also, for vertical centering of images, you have the handy `<r:asset:top_padding container="<container height>" [size="icon"]/>` tag. Working example:
+
+    <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:caption/>">
+        </li>
+      </r:assets:each>
+    </ul>
+
+## Contributions
+
+If you would like to contribute, please [fork the project][fork] and submit a [pull request][pull-request].
+
+[fork]: http://help.github.com/fork-a-repo/
+[pull-request]: http://help.github.com/send-pull-requests/
+
+Pull requests with working tests are preferred and have a greater chance of being merged.
+
+## TODO
+
+* Progress bars while uploading assets
+* Warning if you try and save a page while assets are still uploading
+* Radius tags for the HTML video and audio elements
+* Auxiliary extension to add video transcoding support
+
+## Authors
+
+* Keith Bingman
+* John Long
+* William Ross
+
+Copyright 2011 the Radiant team. Released under the same terms as Radiant.

data/Rakefile

@@ -0,0 +1,109 @@
+# Determine where the RSpec plugin is by loading the boot
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["RADIANT_ENV_FILE"]
+    require File.dirname(ENV["RADIANT_ENV_FILE"]) + "/boot"
+  when File.dirname(__FILE__) =~ %r{vendor/radiant/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../")}/config/boot"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../")}/config/boot"
+  end
+end
+
+require 'rake'
+require 'rdoc/task'
+require 'rake/testtask'
+
+rspec_base = File.expand_path(RADIANT_ROOT + '/vendor/plugins/rspec/lib')
+$LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base)
+require 'spec/rake/spectask'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+# Cleanup the RADIANT_ROOT constant so specs will load the environment
+Object.send(:remove_const, :RADIANT_ROOT)
+
+extension_root = File.expand_path(File.dirname(__FILE__))
+
+task :default => [:spec, :features]
+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
+
+task :features => 'spec:integration'
+
+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
+  
+  desc "Run the Cucumber features"
+  Cucumber::Rake::Task.new(:integration) do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+    # t.feature_pattern = "#{extension_root}/features/**/*.feature"
+    t.profile = "default"
+  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 clipped extension.'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ClippedExtension'
+  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/app/controllers/admin/assets_controller.rb

@@ -0,0 +1,66 @@
+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
+    @assets, @page_attachments = [], []
+    params[:asset][:asset].to_a.each do |uploaded_asset|
+      @asset = Asset.create(:group => params[:asset][:group], :asset => uploaded_asset, :title => params[:asset][:title], :caption => params[:asset][:caption])
+      if params[:for_attachment]
+        @page = Page.find_by_id(params[:page_id]) || Page.new
+        @page_attachments << @page_attachment = @asset.page_attachments.build(:page => @page)
+      end
+      @assets << @asset
+    end
+    if params[:for_attachment]
+      render :partial => 'admin/page_attachments/attachment', :collection => @page_attachments
+    else 
+      response_for :create
+    end
+  end
+  
+  def refresh
+    if params[:id]
+      @asset = Asset.find(params[:id])
+      @asset.asset.reprocess!
+      flash[:notice] = t('clipped_extension.thumbnails_refreshed')
+      redirect_to edit_admin_asset_path(@asset)
+    else
+      render
+    end
+  end
+  
+  only_allow_access_to :regenerate,
+    :when => [:admin],
+    :denied_url => { :controller => 'admin/assets', :action => 'index' },
+    :denied_message => 'You must have admin privileges to refresh the whole asset set.'
+
+  def regenerate
+    Asset.all.each { |asset| asset.asset.reprocess! }
+    flash[:notice] = t('clipped_extension.all_thumbnails_refreshed')
+    redirect_to admin_assets_path
+  end
+  
+end

data/app/controllers/admin/page_attachments_controller.rb

@@ -0,0 +1,18 @@
+class Admin::PageAttachmentsController < Admin::ResourceController
+  helper 'admin/assets'
+    
+  def new
+    render :partial => 'attachment', :object => model
+  end
+  
+  def load_model
+    begin
+      @asset = Asset.find(params[:asset_id])
+      @page = params[:page_id].blank? ? Page.new : Page.find_by_id(params[:page_id])
+    rescue ActiveRecord::RecordNotFound
+      render :nothing => true, :layout => false
+    end
+    self.model = PageAttachment.new(:asset => @asset, :page => @page)
+  end
+  
+end

data/app/helpers/admin/assets_helper.rb

@@ -0,0 +1,16 @@
+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)
+    radius_tag = asset.asset_type.default_radius_tag || 'link';
+    link_to t('clipped_extension.insert'), '#', :class => 'insert_asset', :rel => "#{radius_tag}_#{Radiant.config['assets.insertion_size']}_#{asset.id}"
+  end
+  
+  def asset_attachment_link(asset)
+    link_to t("clipped_extension.attach"), new_admin_page_attachment_path(:asset_id => asset.id), :class => 'attach_asset', :rel => "attach_#{asset.id}"
+  end
+  
+end

data/app/helpers/admin/page_attachments_helper.rb

@@ -0,0 +1,2 @@
+module Admin::PageAttachmentsHelper
+end

data/app/models/asset.rb

@@ -0,0 +1,237 @@
+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.for(attachment).paperclip_styles
+                    },
+                    :processors => lambda { |asset|
+                      asset.paperclip_processors
+                    },
+                    :whiny => false,
+                    :storage => Radiant.config["paperclip.storage"],
+                    :path => Radiant.config["paperclip.path"],
+                    :url => Radiant.config["paperclip.url"],
+                    :fog_credentials => RadiantClippedExtension::Cloud.credentials,
+                    :fog_directory => Radiant.config["paperclip.fog.directory"],
+                    :fog_public => Radiant.config["paperclip.fog.public?"] || true,
+                    :fog_host => RadiantClippedExtension::Cloud.host
+
+  before_save :assign_title
+  before_save :assign_uuid
+  
+  after_post_process :read_dimensions
+
+  validates_attachment_presence :asset, :message => "You must choose a file to upload!"
+  if Radiant.config["paperclip.skip_filetype_validation"] != "true" && Radiant.config['paperclip.content_types']
+    validates_attachment_content_type :asset, :content_type => Radiant.config["paperclip.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.for(asset)
+  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='original')
+    style_name == 'original' || paperclip_styles.keys.include?(style_name.to_sym)
+  end
+
+  def basename
+    File.basename(asset_file_name, ".*") if asset_file_name
+  end
+
+  def extension(style_name='original')
+     if style_name == 'original'
+       return original_extension 
+     elsif style = paperclip_styles[style_name.to_sym]
+       return style.format 
+     else
+       return original_extension
+     end
+  end
+  
+  def original_extension
+    return asset_file_name.split('.').last.downcase if asset_file_name
+  end
+
+  def attached_to?(page)
+    pages.include?(page)
+  end
+  
+  def original_geometry
+    @original_geometry ||= Paperclip::Geometry.new(original_width, original_height)
+  end
+  
+  def geometry(style_name='original')
+    raise Paperclip::StyleError, "Requested style #{style_name} is not defined for this asset." unless has_style?(style_name)
+    @geometry ||= {}
+    begin
+      @geometry[style_name] ||= if style_name.to_s == 'original'
+        original_geometry
+      else
+        style = self.asset.styles[style_name.to_sym]
+        original_geometry.transformed_by(style.geometry)    # this can return dimensions for fully specified style sizes but not for relative sizes when there are no original dimensions
+      end
+    rescue Paperclip::TransformationError => e
+      Rails.logger.warn "geometry transformation error: #{e}"
+      original_geometry                                     # returns a blank geometry if the real geometry cannot be calculated
+    end
+  end
+
+  def aspect(style_name='original')
+    geometry(style_name).aspect
+  end
+
+  def orientation(style_name='original')
+    a = aspect(style_name)
+    case
+    when a == nil?
+      'unknown'
+    when a < 1.0 
+      'vertical'
+    when a > 1.0 
+      'horizontal'
+    else
+      'square'
+    end
+  end
+
+  def width(style_name='original')
+    geometry(style_name).width.to_i
+  end
+
+  def height(style_name='original')
+    geometry(style_name).height.to_i
+  end
+
+  def square?(style_name='original')
+    geometry(style_name).square?
+  end
+
+  def vertical?(style_name='original')
+    geometry(style_name).vertical?
+  end
+
+  def horizontal?(style_name='original')
+    geometry(style_name).horizontal?
+  end
+  
+  def dimensions_known?
+    original_width? && original_height?
+  end
+  
+private
+
+  # at this point the file queue will not have been written
+  # but the upload should be in place. We read dimensions from the
+  # original file and calculate thumbnail dimensions later, on demand.
+  
+  def read_dimensions
+    if image?
+      if file = asset.queued_for_write[:original]
+        geometry = Paperclip::Geometry.from_file(file)
+        self.original_width = geometry.width
+        self.original_height = geometry.height
+        self.original_extension = File.extname(file.path)
+      end
+    end
+    true
+  end
+
+  def assign_title
+    self.title = basename unless title?
+  end
+  
+  def assign_uuid
+    self.uuid = UUIDTools::UUID.timestamp_create.to_s unless uuid?
+  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