trusty-clipped-extension 1.0.0

data/lib/clipped/engine.rb

@@ -0,0 +1,5 @@
+module Clipped
+  class Engine < Rails::Engine
+    paths["app/helpers"] = []
+  end
+end

data/lib/clipped_admin_ui.rb

@@ -0,0 +1,32 @@
+module ClippedAdminUI
+
+ def self.included(base)
+   base.class_eval do
+
+      attr_accessor :asset
+      alias_method :assets, :asset
+      
+      protected
+
+        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
+end
+

data/lib/cloud.rb

@@ -0,0 +1,41 @@
+module TrustyCmsClippedExtension
+
+  module Cloud
+
+    def self.credentials
+      case TrustyCms.config["paperclip.fog.provider"]
+      when "AWS"
+        {
+          :provider => "AWS",
+          :aws_access_key_id => TrustyCms.config["paperclip.s3.key"],
+          :aws_secret_access_key => TrustyCms.config["paperclip.s3.secret"],
+          :region => TrustyCms.config["paperclip.s3.region"],
+        }
+      when "Google"
+        {
+          :provider => "Google",
+          :rackspace_username => TrustyCms.config["paperclip.google_storage.access_key_id"],
+          :rackspace_api_key  => TrustyCms.config["paperclip.google_storage.secret_access_key"]
+        }
+      when "Rackspace"
+        {
+          :provider => "Rackspace",
+          :rackspace_username => TrustyCms.config["paperclip.rackspace.username"],
+          :rackspace_api_key  => TrustyCms.config["paperclip.rackspace.api_key"]
+        }
+      end
+    end
+
+    def self.host
+      return TrustyCms.config["paperclip.fog.host"] if TrustyCms.config["paperclip.fog.host"]
+      case TrustyCms.config["paperclip.fog.provider"]
+      when "AWS"
+        "http://#{TrustyCms.config['paperclip.fog.directory']}.s3.amazonaws.com"
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/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/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 ASC"
+      has_many :assets, :through => :page_attachments, :order => "page_attachments.position ASC"
+      accepts_nested_attributes_for :page_attachments, :allow_destroy => true
+    }
+  end
+  
+end

data/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/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

data/lib/tasks/clipped_extension_tasks.rake

@@ -0,0 +1,124 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :clipped do
+      
+      desc "Runs the migration of the Clipped extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name} WHERE version = 'Assets-20110513205050'").any?
+          puts "Assimilating Assets extension migration 20110513205050"
+          ClippedExtension.migrator.new(:up, ClippedExtension.migrations_path).send(:assume_migrated_upto_version, '20110513205050')
+        end
+        
+        if ENV["VERSION"]
+          ClippedExtension.migrator.migrate(ENV["VERSION"].to_i)
+          Rake::Task['db:schema:dump'].invoke
+        else
+          ClippedExtension.migrator.migrate
+          Rake::Task['db:schema:dump'].invoke
+        end
+      end
+      
+      desc "Copies public assets of the Clipped extension to the instance public/ directory."
+      task :update => [:environment, :initialize] do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from ClippedExtension"
+        Dir[ClippedExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(ClippedExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p Rails.root + directory, :verbose => false
+          cp_r file, Rails.root + path, :verbose => false
+        end
+
+        desc "Syncs all available translations for this ext to the English ext master"
+        task :sync => :environment do
+          # The main translation root, basically where English is kept
+          language_root = ClippedExtension.get_translation_keys(language_root)
+
+          Dir["#{language_root}/*.yml"].each do |filename|
+            next if filename.match('_available_tags')
+            basename = File.basename(filename, '.yml')
+            puts "Syncing #{basename}"
+            (comments, other) = TranslationSupport.read_file(filename, basename)
+            words.each { |k,v| other[k] ||= words[k] }  # Initializing hash variable as empty if it does not exist
+            other.delete_if { |k,v| !words[k] }         # Remove if not defined in en.yml
+            TranslationSupport.write_file(filename, basename, comments, other)
+          end
+        end
+      end
+      
+      desc "Exports assets from database to assets directory"
+      task :export => :environment do
+        asset_path = File.join(Rails.root, "assets")
+        mkdir_p asset_path
+        Asset.find(:all).each do |asset|
+          puts "Exporting #{asset.asset_file_name}"
+          cp asset.asset.path, File.join(asset_path, asset.asset_file_name)
+        end
+        puts "Done."
+      end
+
+      desc "Imports assets to database from assets directory"
+      task :import => :environment do
+        asset_path = File.join(Rails.root, "assets")
+        if File.exist?(asset_path) && File.stat(asset_path).directory?
+          Dir.glob("#{asset_path}/*").each do |file_with_path|
+            if File.stat(file_with_path).file?
+              new_asset = File.new(file_with_path) 
+              puts "Creating #{File.basename(file_with_path)}"
+              Asset.create :asset => new_asset
+            end
+          end
+        end
+      end
+      
+      desc "Migrates page attachments from the original page attachments extension into new Assets"
+      task :migrate_from_page_attachments => :environment do
+        puts "This task can clean up traces of the page_attachments (think table records and files currently in /public/page_attachments).
+If you would like to use this mode type \"yes\", type \"no\" or just hit enter to leave them untouched for now."
+        answer = STDIN.gets.chomp
+        erase_tracks = answer.eql?('yes') ? true : false
+        OldPageAttachment.find_all_by_parent_id(nil).each do |opa|
+          asset = opa.create_paperclipped_record
+          # move the actual file
+          old_dir = "#{Rails.root}/public/page_attachments/0000/#{opa.id.to_s.rjust(4,'0')}"
+          new_dir = "#{Rails.root}/public/assets/#{asset.id}"
+          puts "Copying #{old_dir.gsub(Rails.root, '')}/#{opa.filename} to #{new_dir.gsub(Rails.root, '')}/#{opa.filename}..."
+          mkdir_p new_dir
+          cp old_dir + "/#{opa.filename}", new_dir + "/#{opa.filename}"
+          # remove old record and remainings
+          if erase_tracks
+            rm_rf old_dir
+          end
+        end
+        # regenerate thumbnails
+        puts "Regenerating asset thumbnails"
+        ENV['CLASS'] = 'Asset'
+        Rake::Task['paperclip:refresh'].invoke
+        puts "Done."
+      end
+      
+      desc "Migrates from old 'assets' extension."
+      task :migrate_from_assets => :environment do
+        Asset.delete_all("thumbnail IS NOT NULL OR parent_id IS NOT NULL")
+        ActiveRecord::Base.connection.tap do |c|
+          c.rename_column :assets, :filename, :asset_file_name
+          c.rename_column :assets, :content_type, :asset_content_type
+          c.rename_column :assets, :size, :asset_file_size
+          c.remove_column :assets, :parent_id
+          c.remove_column :assets, :thumbnail
+        end
+
+        ClippedExtension.migrator.new(:up, ClippedExtension.migrations_path).send(:assume_migrated_upto_version, 3)
+        ClippedExtension.migrator.migrate
+      end
+
+      desc "Generate an example initializer"
+      task :initialize do
+        puts "Copying initializer from ClippedExtension"
+        cp ClippedExtension.root + "/lib/generators/templates/clipped_config.rb", Rails.root + "/config/initializers/", :verbose => false
+      end
+
+    end
+  end
+end

data/lib/tasks/paperclip_tasks.rake

@@ -0,0 +1,79 @@
+def obtain_class
+  class_name = ENV['CLASS'] || ENV['class']
+  raise "Must specify CLASS" unless class_name
+  @klass = Object.const_get(class_name)
+end
+
+def obtain_attachments
+  name = ENV['ATTACHMENT'] || ENV['attachment']
+  raise "Class #{@klass.name} has no attachments specified" unless @klass.respond_to?(:attachment_definitions)
+  if !name.blank? && @klass.attachment_definitions.keys.include?(name)
+    [ name ]
+  else
+    @klass.attachment_definitions.keys
+  end
+end
+
+def for_all_attachments
+  klass = obtain_class
+  names = obtain_attachments
+  ids   = klass.connection.select_values(klass.send(:construct_finder_sql, :select => 'id'))
+
+  ids.each do |id|
+    instance = klass.find(id)
+    names.each do |name|
+      result = if instance.send("#{ name }?")
+                 yield(instance, name)
+               else
+                 true
+               end
+      print result ? "." : "x"; $stdout.flush
+    end
+  end
+  puts " Done."
+end
+
+namespace :paperclip do
+  desc "Refreshes both metadata and thumbnails."
+  task :refresh => ["paperclip:refresh:metadata", "paperclip:refresh:thumbnails"]
+
+  namespace :refresh do
+    desc "Regenerates thumbnails for a given CLASS (and optional ATTACHMENT)."
+    task :thumbnails => :environment do
+      errors = []
+      for_all_attachments do |instance, name|
+        result = instance.send(name).reprocess!
+        errors << [instance.id, instance.errors] unless instance.errors.blank?
+        result
+      end
+      errors.each{|e| puts "#{e.first}: #{e.last.full_messages.inspect}" }
+    end
+
+    desc "Regenerates content_type/size metadata for a given CLASS (and optional ATTACHMENT)."
+    task :metadata => :environment do
+      for_all_attachments do |instance, name|
+        if file = instance.send(name).to_file
+          instance.send("#{name}_file_name=", instance.send("#{name}_file_name").strip)
+          instance.send("#{name}_content_type=", file.content_type.strip)
+          instance.send("#{name}_file_size=", file.size) if instance.respond_to?("#{name}_file_size")
+          instance.save(false)
+        else
+          true
+        end
+      end
+    end
+  end
+
+  desc "Cleans out invalid attachments. Useful after you've added new validations."
+  task :clean => :environment do
+    for_all_attachments do |instance, name|
+      instance.send(name).send(:validate)
+      if instance.send(name).valid?
+        true
+      else
+        instance.send("#{name}=", nil)
+        instance.save
+      end
+    end
+  end
+end