radiant-clipped-extension-add-group 1.1.2

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 :named_scope, plural.to_sym, :conditions => condition
+    Asset.send :named_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
+    Radiant.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 = Radiant.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
+    Radiant::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

data/app/models/old_page_attachment.rb

@@ -0,0 +1,26 @@
+class OldPageAttachment < ActiveRecord::Base
+    def create_paperclipped_record
+      options = {
+        :asset_file_size => size,
+        :asset_file_name => filename,
+        :asset_content_type => content_type,
+        :created_by_id => created_by
+      }
+      
+      # In newer versions of page_attachments we have title and description fields.
+      options[:title] = title if respond_to?(:title)
+      options[:caption] = description if respond_to?(:description)
+      
+      a = Asset.new(options)
+      a.save
+      
+      # Re-attach the asset to it's page
+      page = Page.find(page_id)
+      p = PageAttachment.create(:asset_id => a.id, :page_id => page.id)
+      
+      # Circumvent acts_as_list before_create filter to set the original page_attachment position.
+      PageAttachment.update_all("position=#{position}", "id=#{p.id}") if respond_to?(:position)
+      
+      a
+    end          
+end

data/app/models/page_attachment.rb

@@ -0,0 +1,20 @@
+class PageAttachment < ActiveRecord::Base
+  belongs_to :asset
+  belongs_to :page
+  attr_accessor :selected
+
+  accepts_nested_attributes_for :asset
+  
+  acts_as_list :scope => :page_id
+  
+  def selected?
+    !!selected
+  end
+  
+  # a small change to the method in acts_as_list so that we don't override 
+  # the position value if it has already been set (as it usually is for new attachments)
+  def add_to_list_bottom
+    self[position_column] ||= bottom_position_in_list.to_i + 1
+  end
+  
+end

data/app/views/admin/assets/_asset.html.haml

@@ -0,0 +1,12 @@
+- asset ||= @asset
+- asset_type = asset.image? ? "image" : "link"
+
+%li{:class => "#{asset_type} asset", :id => "asset_#{asset.id}"}
+  .front
+    .thumbnail= image_tag asset.thumbnail(:thumbnail)
+  .back
+    .title= asset.title
+    %ul.actions
+      %li
+        = link_to t('clipped_extension.edit'), edit_admin_asset_url(asset), :class => 'edit_asset'
+        = link_to t('clipped_extension.remove'), remove_admin_asset_url(asset), :class => 'remove_asset'

data/app/views/admin/assets/_asset_table.html.haml

@@ -0,0 +1,33 @@
+- group_assets ||= @assets.group_by{|i| i.group}
+- page ||= @page
+- with_pagination ||= false
+
+- if assets.empty?
+  %p
+    = t("clipped_extension.no_assets")
+- else
+  - if with_pagination && assets.respond_to?(:total_pages) && assets.total_pages > 1
+    = pagination_for(assets, pagination_parameters.merge(:depaginate => false, :params => {:controller => 'admin/assets', :action => 'index', :id => nil, :format => 'js'}))
+
+  - group_assets.each do |group, assets|
+    %h2 #{"Group: " + group.to_s}
+    %ul
+      - assets.each_with_index do |asset, index|
+        - asset_type = asset.image? ? "image" : "link"
+        %li{:class => "#{asset_type} asset", :id => "asset_#{asset.id}"}
+          .front
+            .thumbnail= image_tag asset.thumbnail(:thumbnail)
+          .back
+            .title
+              = asset.title
+            %ul.actions
+              - if @page
+                %li= asset_insertion_link(asset)
+                %li= asset_attachment_link(asset)
+              - else
+                %li= link_to t('clipped_extension.edit'), admin_asset_path(asset), :class => 'edit'
+                %li= link_to t("clipped_extension.remove"), remove_admin_asset_path(asset), :class => "delete"
+    %p{:style => 'clear: both; height: 2em'}  
+            
+  - if with_pagination && assets.respond_to?(:total_pages) && assets.total_pages > 1
+    = pagination_for(assets, pagination_parameters.merge(:depaginate => false, :param_name => 'p', :params => {:controller => 'admin/assets', :action => 'index', :id => nil, :format => 'js', :page_id => (page && page.id), :pp => assets.per_page }))

data/app/views/admin/assets/_errors.html.haml

@@ -0,0 +1,3 @@
+- if @asset.errors && !@asset.errors.empty?
+  %p#asset_errors
+    %strong= t("clipped_extension.asset_errors", :errors => @asset.errors.full_messages.to_sentence)

data/app/views/admin/assets/_form.html.haml

@@ -0,0 +1,25 @@
+= render_region :form_top
+- render_region :form do |form|
+  - form.edit_title do
+    %p.title
+      %label{ :for => "asset_title" }
+        = t("clipped_extension.title")
+      = f.text_field :title, :class => 'textbox', :maxlength => 100 
+    %p.group
+      %label{ :for => "asset_group" }
+        = t("clipped_extension.group")
+      = f.text_field :group, :class => 'textbox', :maxlength => 100 
+  - form.edit_metadata do
+    .drawer
+      .drawer_contents#attributes
+        %table.fieldset
+          %tr
+            %th.label
+              %label{ :for => "asset_caption" }
+                = t("clipped_extension.caption")
+            %td.field
+              = f.text_field :caption, :class => 'textbox', :maxlength => 255 
+          = render_region :extended_metadata, :locals => {:f => f}
+      .drawer_handle
+        %a.toggle.more{:href=>'#attributes', :rel=>"toggle[attributes]"}
+          = t('more')

data/app/views/admin/assets/_page_assets.html.haml

@@ -0,0 +1,12 @@
+- unless @page.assets.empty?
+  - @page.page_attachments.each do |attachment|
+    = render :partial => 'admin/assets/asset', :locals => { :attachment => attachment }
+- else
+  %li
+    %p.note
+      = t("clipped_extension.no_attached_assets")
+    
+%script{ :type => "text/javascript" }
+  Asset.MakeDraggables();
+
+= sortable_element 'attachments', :url => reorder_assets_url(@page), :constraint => 'horizontal', :handle => 'reorder', :ghosting => false, :complete => visual_effect(:highlight, 'assets')

data/app/views/admin/assets/_search.html.haml

@@ -0,0 +1,17 @@
+- form_tag(admin_assets_path, :id=>'filesearchform', :method => 'get', :class=>"search") do
+  - if @page
+    = hidden_field_tag "page_id", @page.id
+    = hidden_field_tag "p", params['p'] || 1
+    = hidden_field_tag "pp", params['pp'] || 20
+
+  .asset_filters
+    = link_to t("asset_types.all"), admin_assets_url, :id => "select_all", :class => params[:filter].blank? ? "deselective pressed" : "deselective"
+    - AssetType.all.each do |type|
+      - unless type.name == :other
+        = link_to t("asset_types.#{type.plural}"), admin_assets_url(:filter => type.name), :rel => type.name.to_s, :class => params[:filter] == type.name.to_s ? "selective pressed" : "selective"
+  .right
+    %input{:type=>"search", :class=>"search", :name=>"search", :value=>h(params[:search]), :placeholder=>"Search", :results=>0, :size=>30} 
+  
+  #type_boxes{:style => "display: none"}
+    - AssetType.all.each do |type|
+      = check_box_tag 'filter[]',  type.name.to_s, false, :id => "#{type.name}-check", :class => 'selective'

data/app/views/admin/assets/_search_results.html.haml

@@ -0,0 +1,17 @@
+%ul#search_list
+  - unless @assets.empty?
+    - @assets.each do |asset| 
+      =# render :partial => 'asset', :locals => { :asset => asset, :page => @page }
+      = render :partial => 'admin/assets/asset', :locals => { :asset_url => asset.asset.url, :asset_id => asset.id, :asset_type => 'image', :asset_title => asset.title, :asset_thumbnail => asset.thumbnail(:thumbnail), :page => @page }
+
+  - else
+    %li
+      %p.note
+        = t("clipped_extension.no_assets_found")
+      
+%script
+  Asset.MakeDroppables();
+  Asset.MakeDraggables();
+  Event.addBehavior({ '.asset a' : Asset.DisableLinks, 'a.add_asset' : Asset.AddToPage });
+
+  

data/app/views/admin/assets/edit.html.haml

@@ -0,0 +1,41 @@
+- include_stylesheet 'admin/assets' 
+= render_region :top 
+
+- render_region :main do |main|
+  - main.edit_header do
+    %h1= t("clipped_extension.asset_edit_title")
+  
+  - main.edit_form do
+    - form_for :asset, :url => admin_asset_path(@asset), :html => { :method => "put", :multipart => true } do |f|
+      .form_area
+        = render :partial => "form", :locals => { :f => f }
+        
+        %div.content
+          %p
+            %label.filename
+              = "#{t("clipped_extension.filename")}: #{@asset.asset_file_name unless @asset.new_record?}"
+          %p.asset
+            - display_size = Radiant::config['assets.display_size'] || 'normal'
+            = image_tag @asset.thumbnail(display_size.to_sym), :class => 'preview'
+
+          = updated_stamp @asset
+          = text_field_tag "", @asset.thumbnail, :style => "width: 550px"
+        
+        %p.upload
+          %label.upload
+            = t("clipped_extension.replace_file")
+          = f.file_field :asset, :class => "", :style => "width: 100%"
+        
+        .buttons
+          = save_model_button(@asset)
+          = save_model_and_continue_editing_button(@asset)
+          = t("or")
+          = link_to t("cancel"), admin_assets_path
+  
+  - main.edit_regenerate do
+    - if current_user.admin? or current_user.designer?
+      %p= t("clipped_extension.regenerate_thumbnails")
+      
+      - form_tag refresh_admin_asset_path(@asset), :method => :put do
+        %p.asset_buttons
+          %input.button{ :type => "submit", :value => t("clipped_extension.regenerate") }