trusty-clipped-extension 1.0.0

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}_#{TrustyCms.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,241 @@
+class Asset < ActiveRecord::Base
+  include Paperclip::Glue
+
+  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"
+
+  scope :latest, lambda { |limit|
+    { :order => "created_at DESC", :limit => limit }
+  }
+
+  scope :of_types, lambda { |types|
+    mimes = AssetType.slice(*types).map(&:mime_types).flatten
+    { :conditions => ["asset_content_type IN (#{mimes.map{'?'}.join(',')})", *mimes] }
+  }
+
+  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}%" }] }
+  }
+
+  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 => TrustyCms.config["paperclip.storage"],
+                    :path => TrustyCms.config["paperclip.path"],
+                    :url => TrustyCms.config["paperclip.url"],
+                    :fog_credentials => TrustyCmsClippedExtension::Cloud.credentials,
+                    :fog_directory => TrustyCms.config["paperclip.fog.directory"],
+                    :fog_public => TrustyCms.config["paperclip.fog.public?"] || true,
+                    :fog_host => TrustyCmsClippedExtension::Cloud.host
+
+  validates_attachment_content_type :asset, :content_type => ["image/jpg", "image/jpeg", "image/png", "image/gif", "application/pdf", "application/javascript", "text/javascript", "text/css"]
+
+  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 TrustyCms.config["paperclip.skip_filetype_validation"] != "true" && TrustyCms.config['paperclip.content_types']
+    validates_attachment_content_type :asset, :content_type => TrustyCms.config["paperclip.content_types"].gsub(' ','').split(',')
+  end
+  validates_attachment_size :asset, :less_than => ( TrustyCms.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) { where *args }
+    end
+
+    def count_with_asset_types(asset_types, *args)
+      with_asset_types(asset_types) { where(*args).count }
+    end
+
+    def with_asset_types(asset_types, &block)
+      with_scope(where(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/app/models/asset_type.rb

@@ -0,0 +1,241 @@
+class AssetType
+  
+  # The Asset Type encapsulates a type of attachment.
+  # Conventionally this would a sensible category like 'image' or 'video'
+  # that should be processed and presented in a particular way.
+  # An AssetType currently provides:
+  #   * processor definitions for paperclip
+  #   * styles definitions for paperclip
+  #   * mime type list for file recognition
+  #   * selectors and scopes for retrieving this (or not this) category of asset
+  #   * radius tags for those subsets of assets (temporarily removed pending discussion of interface)
+  
+  @@types = []
+  @@type_lookup = {}
+  @@extension_lookup = {}
+  @@mime_lookup = {}
+  @@default_type = nil
+  attr_reader :name, :processors, :styles, :icon_name, :catchall, :default_radius_tag
+  
+  def initialize(name, options = {})
+    options = options.symbolize_keys
+    @name = name
+    @icon_name = options[:icon] || name
+    @processors = options[:processors] || []
+    @styles = options[:styles] || {}
+    @styles = standard_styles if @styles == :standard
+    @default_radius_tag = options[:default_radius_tag] || 'link'
+    @extensions = options[:extensions] || []
+    @extensions.each { |ext| @@extension_lookup[ext] ||= self }
+    @mimes = options[:mime_types] || []
+    @mimes.each { |mimetype| @@mime_lookup[mimetype] ||= self }
+
+    this = self
+    Asset.send :define_method, "#{name}?".intern do this.mime_types.include?(asset_content_type) end 
+    Asset.send :define_class_method, "#{name}_condition".intern do this.condition; end
+    Asset.send :define_class_method, "not_#{name}_condition".intern do this.non_condition; end
+    Asset.send :scope, plural.to_sym, :conditions => condition
+    Asset.send :scope, "not_#{plural}".to_sym, :conditions => non_condition
+    
+    self.define_radius_tags
+    @@types.push self
+    @@type_lookup[@name] = self
+  end
+  
+  def plural
+    name.to_s.pluralize
+  end
+
+  def icon(style_name='icon')
+    if File.exist?(Rails.root + "public/images/admin/assets/#{icon_name}_#{style_name.to_s}.png")
+      return "/images/admin/assets/#{icon_name}_#{style_name.to_s}.png"
+    else
+      return "/images/admin/assets/#{icon_name}_icon.png"
+    end
+  end
+  
+  def icon_path(style_name='icon')
+    Rails.root + "public#{icon(style_name)}"
+  end
+  
+  def condition
+    if @mimes.any?
+      ["asset_content_type IN (#{@mimes.map{'?'}.join(',')})", *@mimes]
+    else
+      self.class.other_condition
+    end
+  end
+  
+  def sanitized_condition
+    ActiveRecord::Base.send :sanitize_sql_array, condition
+  end
+
+  def non_condition
+    if @mimes.any?
+      ["NOT asset_content_type IN (#{@mimes.map{'?'}.join(',')})", *@mimes]
+    else
+      self.class.non_other_condition
+    end
+  end
+
+  def sanitized_non_condition
+    ActiveRecord::Base.send :sanitize_sql_array, non_condition
+  end
+
+  def mime_types
+    @mimes
+  end
+
+  def paperclip_processors
+    TrustyCms.config["assets.create_#{name}_thumbnails?"] ? processors : []
+  end
+  
+  # Parses and combines the various ways in which paperclip styles can be defined, and normalises them into
+  # the format that paperclip expects. Note that :styles => :standard has already been replaced with the 
+  # results of a call to standard_styles.
+  # Styles are passed to paperclip as a hash and arbitrary keys can be passed through from configuration.
+  #
+  def paperclip_styles
+    # Styles are not relevant if processors are not defined.
+    # TODO: should this default to an icon set?
+    @paperclip_styles ||= if paperclip_processors.any?
+      normalize_style_rules(configured_styles.merge(styles))
+    else
+      {}
+    end
+    @paperclip_styles
+  end
+  
+  # Takes a motley collection of differently-defined styles and renders them into the standard hash-of-hashes format.
+  # Solitary strings are assumed to be 
+  #TODO: define permitted and/or expected options for the asset type and pass through that subset of the style-definition hash
+  #
+  def normalize_style_rules(styles={})
+    styles.each_pair do |name, rule|
+      unless rule.is_a? Hash
+        if rule =~ /\=/
+          parameters = rule.split(',').collect{ |parameter| parameter.split('=') }              # array of pairs
+          rule = Hash[parameters].symbolize_keys                                     # into hash of :first => last
+        else
+          rule = {:geometry => rule}                                                 # simplest case: name:geom|name:geom
+        end
+      end
+      rule[:geometry] ||= rule.delete(:size)
+      styles[name.to_sym] = rule
+    end
+    styles
+  end
+  
+  def standard_styles
+    {
+      :native => { :geometry => "", :format => :jpg },
+      :icon => { :geometry => '42x42#', :format => :png },
+      :thumbnail => { :geometry => '100x100#', :format => :png }
+    }
+  end
+  
+  # Paperclip styles are defined in the config entry `assets.thumbnails.asset_type`, with the format:
+  # foo:key-x,key=y,key=z|bar:key-x,key=y,key=z
+  # where 'key' can be any parameter understood by your paperclip processors. Usually they include :geometry and :format.
+  # A typical entry would be:
+  #
+  #   standard:geometry=640x640>,format=jpg
+  #
+  # This method parses that string and returns the defined styles as a hash of style-defining strings that will later be normalized into hashes.
+  #
+  def configured_styles
+    @configured_styles ||= if style_definitions = TrustyCms.config["assets.thumbnails.#{name}"]
+      style_definitions.split('|').each_with_object({}) do |definition, styles|
+        name, rule = definition.split(':')
+        styles[name.strip.to_sym] = rule.to_s.strip
+      end
+    else
+      {}
+    end
+  end
+  
+  def legacy_styles
+    TrustyCms::config["assets.additional_thumbnails"].to_s.gsub(' ','').split(',').collect{|s| s.split('=')}.inject({}) {|ha, (k, v)| ha[k.to_sym] = v; ha}
+  end
+  
+  def style_dimensions(style_name)
+    if style = paperclip_styles[style_name.to_sym]
+      style[:size]
+    end
+  end
+  
+  def define_radius_tags
+    type = self.name
+    Page.class_eval {
+      tag "asset:if_#{type}" do |tag|
+        tag.expand if find_asset(tag, tag.attr.dup).send("#{type}?".to_sym)
+      end
+      tag "asset:unless_#{type}" do |tag|
+        tag.expand unless find_asset(tag, tag.attr.dup).send("#{type}?".to_sym)
+      end
+    }
+  end
+  
+  # class methods
+  
+  def self.for(attachment)
+    extension = File.extname(attachment.original_filename).sub(/^\.+/, "")
+    from_extension(extension) || from_mimetype(attachment.instance_read(:content_type)) || catchall
+  end
+
+  def self.from_extension(extension)
+    @@extension_lookup[extension]
+  end
+
+  def self.from_mimetype(mimetype)
+    @@mime_lookup[mimetype]
+  end
+  
+  def self.catchall
+    @@default_type ||= self.find(:other)
+  end
+  
+  def self.known?(name)
+    !self.find(name).nil?
+  end
+
+  def self.slice(*types)
+    @@type_lookup.slice(*types.map(&:to_sym)).values if types   # Hash#slice is provided by will_paginate
+  end
+
+  def self.find(type)
+    @@type_lookup[type] if type
+  end
+  def self.[](type)
+    find(type)
+  end
+  
+  def self.all
+    @@types
+  end
+
+  def self.known_types
+    @@types.map(&:name) # to preserve order
+  end
+
+  def self.known_mimetypes
+    @@mime_lookup.keys
+  end
+    
+  def self.mime_types_for(*names)
+    names.collect{ |name| find(name).mime_types }.flatten
+  end
+
+  def self.conditions_for(*names)
+    names.collect{ |name| self.find(name).sanitized_condition }.join(' OR ')
+  end
+
+  def self.non_other_condition
+    ["asset_content_type IN (#{known_mimetypes.map{'?'}.join(',')})", *known_mimetypes]
+  end
+
+  def self.other_condition
+    ["NOT asset_content_type IN (#{known_mimetypes.map{'?'}.join(',')})", *known_mimetypes]
+  end
+
+end