trusty-cms 3.1.11 → 3.2.0

data/vendor/extensions/clipped-extension/lib/asset_tags.rb

@@ -0,0 +1,346 @@
+module AssetTags
+  include TrustyCms::Taggable
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::AssetTagHelper
+  
+  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
+  
+  desc %{
+    The namespace for referencing images and assets.
+    
+    *Usage:* 
+    <pre><code><r:asset [name="asset name"]>...</r:asset></code></pre>
+  }    
+  tag 'asset' do |tag|
+    tag.locals.asset = find_asset(tag, tag.attr) unless tag.attr.empty?
+      tag.expand
+  end
+
+  desc %{
+    Cycles through all assets attached to the current page.  
+    This tag does not require the name 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
+    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 = ""
+    paging = pagination_find_options(tag)
+    assets = paging ? tag.locals.assets.paginate(paging) : tag.locals.assets.all
+    assets.each do |asset|
+      tag.locals.asset = asset
+      result << tag.expand
+    end
+    if paging && assets.total_pages > 1
+      tag.locals.paginated_list = assets
+      result << tag.render('pagination', tag.attr.dup)
+    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 a thumbnail. Put the thumbnail in a
+    container with specified height and using this tag you can vertically
+    align the image within its 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, "'container' attribute required" unless options['container']
+    size = options['size'] ? options.delete('size') : 'icon'
+    raise TagError, "asset #{tag.locals.asset.title} has no '#{size}' thumbnail" unless tag.locals.asset.has_style?(size)
+    container = options.delete('container')
+    ((container.to_i - asset.height(size).to_i)/2).to_s
+  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 %{
+    Returns a string representing the orientation of the asset, which must be imageable. 
+    (ie, it is an image or it has been processed to produce an image). 
+    Can be 'horizontal', 'vertical' or 'square'.
+  }
+  tag 'asset:orientation' do |tag|
+    asset, options = asset_and_options(tag)
+    size = options['size'] ? options.delete('size') : 'original'
+    raise TagError, "asset #{tag.locals.asset.title} has no '#{size}' thumbnail" unless tag.locals.asset.has_style?(size)
+    asset.orientation(size)
+  end
+
+  desc %{
+    Returns the aspect ratio of the asset, which must be an image.
+  }
+  tag 'asset:aspect' do |tag|
+    asset, options = asset_and_options(tag)
+    size = options['size'] ? options.delete('size') : 'original'
+    raise TagError, "asset #{tag.locals.asset.title} has no '#{size}' thumbnail" unless tag.locals.asset.has_style?(size)
+    asset.aspect(size)
+  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 @name@ or @id@ 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
+    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
+  
+  [:title, :caption, :asset_file_name, :extension, :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:name' do |tag|
+    tag.render('asset:title', tag.attr.dup)
+  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
+    by changing `assets.thumbnails.[type]` in the TrustyCms::Config settings.
+    
+    *Usage:* 
+    <pre><code><r:asset:image [name="asset name" or id="asset id"] [size="icon|thumbnail|whatever"]></code></pre>
+  }    
+  tag 'asset:image' do |tag|
+    tag.locals.asset, options = asset_and_options(tag)
+    size = options.delete('size') || 'original'
+    raise TagError, "asset #{tag.locals.asset.title} has no '#{size}' thumbnail" unless tag.locals.asset.has_style?(size)
+    options['alt'] ||= tag.locals.asset.title
+    url = tag.locals.asset.thumbnail(size)
+    ActionController::Base.helpers.image_tag(url, options)
+  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 [name="asset name" or id="asset id"] [width="100"] [height="100"]>Fallback content</flash></code></pre>
+    
+    *Example with text fallback:*
+    <pre><code><r:asset:flash name="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 name="flash_movie" width="300" height="200">
+        <r:asset:image name="flash_screenshot" />
+      </flash></code></pre>
+  }
+  tag 'asset:flash' do |tag|
+    asset, options = asset_and_options(tag)
+    if tag.locals.asset.flash?
+      url = asset.thumbnail('original')
+      dimensions = [(tag.attr['width'] || asset.width),(tag.attr['height'] || asset.height)]
+      swf_embed_markup url, dimensions, tag.expand
+    end
+  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 [name="asset name" or id="asset id"] [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 [name="asset name" or id="asset id"] [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
+    
+private
+  def asset_and_options(tag)
+    options = tag.attr.dup
+    [find_asset(tag, options), options]
+  end
+  
+  def find_asset(tag, options)
+    tag.locals.asset ||= if title = (options.delete('name') || options.delete('title'))
+      Asset.find_by_title(title)
+    elsif id = options.delete('id')
+      Asset.find_by_id(id)
+    end
+    tag.locals.asset || raise(TagError, "Asset not found.")
+  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
+

data/vendor/extensions/clipped-extension/lib/clipped/engine.rb

@@ -0,0 +1,11 @@
+require 'acts_as_list'
+require 'uuidtools'
+require 'trusty_cms_clipped_extension/cloud'
+require 'paperclip'
+require 'will_paginate/array'
+module Clipped
+  class Engine < Rails::Engine
+    paths["app/helpers"] = []
+
+  end
+end

data/vendor/extensions/clipped-extension/lib/clipped_admin_ui.rb

@@ -0,0 +1,28 @@
+module ClippedAdminUI
+
+ def self.included(base)
+   base.class_eval {
+      attr_accessor :asset
+      alias_method :assets, :asset
+
+        def load_default_asset_regions
+          OpenStruct.new.tap do |asset|
+            asset.edit = TrustyCms::AdminUI::RegionSet.new do |edit|
+              edit.main.concat %w{edit_header edit_form edit_regenerate}
+              edit.form.concat %w{edit_title edit_metadata}
+            end
+            asset.new = asset.edit
+            asset.index = TrustyCms::AdminUI::RegionSet.new do |index|
+              index.top.concat %w{filters}
+              index.bottom.concat %w{}
+              index.thead.concat %w{thumbnail_header content_type_header actions_header}
+              index.tbody.concat %w{thumbnail_cell title_cell content_type_cell actions_cell}
+              index.paginate
+            end
+            asset.remove = asset.index
+          end
+        end
+   }
+  end
+end
+

data/vendor/extensions/clipped-extension/lib/generators/templates/clipped_config.rb

@@ -0,0 +1,53 @@
+TrustyCms.config do |config|
+
+  # Uncomment and change the settings below to customize the Clipped extension
+
+  # The default settings
+  # config["paperclip.url"] = "/system/:attachment/:id/:style/:basename:no_original_style.:extension"
+  # config["paperclip.path"] = ":rails_root/public/system/:attachment/:id/:style/:basename:no_original_style.:extension"
+  # config["paperclip.storage"] = "filesystem"
+  # config["paperclip.skip_filetype_validation"] = true
+  # config["assets.max_asset_size"] = 5 # megabytes
+  # config["assets.display_size"] = "normal"
+  # config["assets.insertion_size"] = "normal"
+  # config["assets.create_image_thumbnails?"] = true
+  # config["assets.create_video_thumbnails?"] = true
+  # config["assets.create_pdf_thumbnails?"] = true
+  # Check http://www.imagemagick.org/script/command-line-processing.php#geometry
+  # for more details on ImageMagick settings for thumbnail generation
+  # config["assets.thumbnails.image"] = "normal:size=640x640>|small:size=320x320>"
+  # config["assets.thumbnails.video"] = "normal:size=640x640>,format=jpg|small:size=320x320>,format=jpg"
+  # config["assets.thumbnails.pdf"] = "normal:size=640x640>,format=jpg|small:size=320x320>,format=jpg"
+
+  # An example of using Amazon S3
+  # add `gem "fog", "~> 1.0"` to your Gemfile and run `bundle install`
+  # config["paperclip.storage"] = "fog"
+  # config["paperclip.path"] = ":attachment/:id/:style/:basename:no_original_style.:extension"
+  # config["paperclip.fog.provider"] = "AWS"
+  # config["paperclip.fog.directory"] = "bucket-name"
+  # config["paperclip.s3.key"] = "S3_KEY"
+  # config["paperclip.s3.secret"] = "S3_SECRET"
+  # optionally use a custom domain name; requires a CNAME DNS record
+  # config["paperclip.fog.host"] = "http://assets.example.com"
+  # optionally set the S3 region of your bucket; defaults to US East
+  # Asia North East => ap-northeast-1
+  # Asia South East => ap-southeast-1
+  # EU West => eu-west-1
+  # US East => us-east-1
+  # US West => us-west-1
+  # config["paperclip.s3.region"] = "us-east-1"
+
+  # An example of using Rackspace Cloud Files
+  # add `gem "fog", "~> 1.0"` to your Gemfile and run `bundle install`
+  # config["paperclip.storage"] = "fog"
+  # config["paperclip.path"] = ":attachment/:id/:style/:basename:no_original_style.:extension"
+  # config["paperclip.fog.provider"] = "Rackspace"
+  # config["paperclip.fog.directory"] = "container-name"
+  # config["paperclip.rackspace.username"] = "RACKSPACE_USERNAME"
+  # config["paperclip.rackspace.api_key"] = "RACKSPACE_API_KEY"
+  # paperclip.fog.host is your Cloud Files CDN URL
+  # config["paperclip.fog.host"] = "http://a.b.c.rackcdn.com"
+  # optionally use a custom domain name; requires a CNAME DNS record
+  # config["paperclip.fog.host"] = "http://assets.example.com"
+
+end

data/vendor/extensions/clipped-extension/lib/page_asset_associations.rb

@@ -0,0 +1,13 @@
+module PageAssetAssociations
+  
+  #TODO: Turn page_attachments into a generic, polymorphic asset-attachment mechanism
+  
+  def self.included(base)
+    base.class_eval {
+      has_many :page_attachments, -> { order 'position desc' }
+      has_many :assets,{ :through => :page_attachments},  -> { order 'page_attachments.position ASC' }
+      accepts_nested_attributes_for :page_attachments, :allow_destroy => true
+    }
+  end
+  
+end

data/vendor/extensions/clipped-extension/lib/paperclip/frame_grab.rb

@@ -0,0 +1,73 @@
+module Paperclip
+  class FrameGrab < Processor
+
+    attr_accessor :time_offset, :current_geometry, :target_geometry, :whiny, :current_format, :target_format
+
+    def initialize(file, options = {}, attachment = nil)
+      super
+      @file = file
+      @time_offset = options[:time_offset] || '-4'
+      geometry = options[:geometry]
+      unless geometry.blank?
+        @crop = geometry[-1,1] == '#'
+        @target_geometry = Geometry.parse(geometry)
+        @current_geometry = Geometry.parse(video_dimensions(file))
+      end
+      @current_format = File.extname(@file.path)
+      @target_format = options[:format] || 'jpg'
+      @basename = File.basename(@file.path, @current_format)
+      @whiny = options[:whiny].nil? ? true : options[:whiny]
+    end
+
+    def crop?
+      !!@crop
+    end
+    
+    def make
+      src = @file
+      dst = Tempfile.new([ @basename, @target_format ].compact.join("."))
+      dst.binmode
+
+      begin
+        # grab frame at offset
+        cmd = %Q[-itsoffset #{time_offset} -i :source -y -vcodec mjpeg -vframes 1 -an -f rawvideo ]
+
+        # if scale-and-crop parameters can be calculated, we pipe to convert for resizing
+        if scale_and_crop = transformation_options
+          cmd << %{pipe: | convert #{scale_and_crop} - #{target_format}:- }
+
+        # otherwise we let ffmpeg resize the to the right size without preserving aspect ratio
+        else
+          cmd << %{-s #{target_geometry} pipe: }
+        end
+
+        # then pipe to composite to overlay video icon
+        cmd << %{| composite -gravity center :icon - :dest }
+        
+        Paperclip.run('ffmpeg', cmd, :source => File.expand_path(src.path), :dest => File.expand_path(dst.path), :icon => AssetType.find(:video).icon_path, :swallow_stderr => false)
+      rescue PaperclipCommandLineError => e
+        raise PaperclipError, "There was an error processing the thumbnail for #{@basename}: #{e}" if whiny
+      end
+      
+      dst
+    end
+    
+    # get video dimensions in nasty hacky way
+    def video_dimensions(file)
+      dim = Paperclip.run('ffmpeg', '-i :source 2>&1', :source => File.expand_path(file.path), :expected_outcodes => [0,1], :swallow_stderr => false)
+      $1 if dim =~ /(\d+x\d+)/
+    end
+    
+    # Duplicated from Thumbnail. We can't just subclass because of assumed compatibility with Geometry.from_file
+    def transformation_options
+      if current_geometry
+        scale, crop = current_geometry.transformation_to(target_geometry, crop?)
+        trans = []
+        trans << "-resize" << %["#{scale}"] unless scale.nil? || scale.empty?
+        trans << "-crop" << %["#{crop}"] << "+repage" if crop
+        trans.join(" ")
+      end
+    end
+    
+  end
+end

data/vendor/extensions/clipped-extension/lib/paperclip/geometry_transformation.rb

@@ -0,0 +1,80 @@
+module Paperclip
+
+  class TransformationError < PaperclipError; end
+  class StyleError < PaperclipError; end
+  
+  class Geometry
+    
+    # Returns a new Geometry object with the the same dimensions as this but with no modifier.
+    def without_modifier
+      Geometry.new(self.width, self.height)
+    end
+    
+    # Returns the dimensions that would result if a thumbnail was created by transforming this geometry into that geometry.
+    # Its purpose is to mimic imagemagick conversions. Used like so:
+    #    file_geometry.transformed_by(style_geometry)
+    # it returns the size of the thumbnail image you would get by applying that rule.
+    # This saves us having to go back to the file, which is expensive with S3.
+    # We understand all the Imagemagick geometry arguments described at http://www.imagemagick.org/script/command-line-processing.php#geometry
+    # including both '^' and paperclip's own '#' modifier.
+    #
+    def transformed_by (other)
+      other = Geometry.parse(other) unless other.is_a? Geometry
+      # if the two geometries are similar, or the destination geometry is a fixed size, the resulting dimensions are fixed
+      return other.without_modifier if self =~ other || ['#', '!', '^'].include?(other.modifier)
+      # otherwise, we apply the transformation
+      raise TransformationError, "geometry is not transformable without both width and height" if self.height == 0 or self.width == 0
+      case other.modifier
+      when '>'
+        (other.width < self.width || other.height < self.height) ? scaled_to_fit(other) : self
+      when '<'
+        (other.width > self.width && other.height > self.height) ? scaled_to_fit(other) : self
+      when '%'
+        scaled_by(other)
+      when '@'
+        scaled_by(other.width * 100 / (self.width * self.height))
+      else
+        scaled_to_fit(other)
+      end
+    end
+    alias :* :transformed_by
+    
+    # Tests whether two geometries are identical in dimensions and modifier. 
+    def == (other)
+      self.to_s == other.to_s
+    end
+    
+    # Tests whether two geometries have the same dimensions, ignoring modifier.
+    def =~ (other)
+      self.height.to_i == other.height.to_i && self.width.to_i == other.width.to_i
+    end
+    
+    # Scales this geometry to fit within that geometry.
+    def scaled_to_fit(other)
+      if (other.width > 0 && other.height == 0)
+        Geometry.new(other.width, self.height * other.width / self.width)
+      elsif (other.width == 0 && other.height > 0)
+        Geometry.new(self.width * other.height / self.height, other.height)
+      else
+        ratio = Geometry.new( other.width / self.width, other.height / self.height )
+        if ratio.square?
+          other.without_modifier
+        elsif ratio.horizontal?
+          Geometry.new(ratio.height * self.width, other.height)
+        else
+          Geometry.new(other.width, ratio.width * self.height)
+        end
+      end
+    end
+    
+    # Scales this geometry by the percentage(s) specified in that geometry.
+    def scaled_by(other)
+      other = Geometry.new("#{other}%") unless other.is_a? Geometry
+      if other.height > 0
+        Geometry.new(self.width * other.width / 100, self.height * other.height / 100)
+      else
+        Geometry.new(self.width * other.width / 100, self.height * other.width / 100)
+      end
+    end
+  end
+end