From 3756a5031f0adc954501c46164489d0dc596a7d3 Mon Sep 17 00:00:00 2001 From: Tod Beardsley Date: Tue, 12 Jun 2012 12:50:08 -0500 Subject: [PATCH] Adding carrierwave to metasploit's gemcache. --- THIRD-PARTY.md | 1 + .../1.9.1/gems/carrierwave-0.6.2/README.md | 785 ++++++++++++++++++ .../gems/carrierwave-0.6.2/lib/carrierwave.rb | 111 +++ .../carrierwave/compatibility/paperclip.rb | 95 +++ .../lib/carrierwave/locale/en.yml | 9 + .../lib/carrierwave/mount.rb | 382 +++++++++ .../lib/carrierwave/orm/activerecord.rb | 66 ++ .../lib/carrierwave/processing/mime_types.rb | 58 ++ .../lib/carrierwave/processing/mini_magick.rb | 254 ++++++ .../lib/carrierwave/processing/rmagick.rb | 284 +++++++ .../lib/carrierwave/sanitized_file.rb | 315 +++++++ .../lib/carrierwave/storage/abstract.rb | 30 + .../lib/carrierwave/storage/file.rb | 56 ++ .../lib/carrierwave/storage/fog.rb | 358 ++++++++ .../lib/carrierwave/test/matchers.rb | 241 ++++++ .../lib/carrierwave/uploader.rb | 45 + .../lib/carrierwave/uploader/cache.rb | 169 ++++ .../lib/carrierwave/uploader/callbacks.rb | 35 + .../lib/carrierwave/uploader/configuration.rb | 136 +++ .../lib/carrierwave/uploader/default_url.rb | 19 + .../lib/carrierwave/uploader/download.rb | 75 ++ .../uploader/extension_whitelist.rb | 49 ++ .../lib/carrierwave/uploader/mountable.rb | 39 + .../lib/carrierwave/uploader/processing.rb | 92 ++ .../lib/carrierwave/uploader/proxy.rb | 77 ++ .../lib/carrierwave/uploader/remove.rb | 23 + .../lib/carrierwave/uploader/serialization.rb | 30 + .../lib/carrierwave/uploader/store.rb | 111 +++ .../lib/carrierwave/uploader/url.rb | 32 + .../lib/carrierwave/uploader/versions.rb | 254 ++++++ .../carrierwave/validations/active_model.rb | 63 ++ .../lib/carrierwave/version.rb | 3 + .../lib/generators/templates/uploader.rb | 55 ++ .../lib/generators/uploader_generator.rb | 7 + .../specifications/carrierwave-0.6.2.gemspec | 65 ++ 35 files changed, 4424 insertions(+) create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/README.md create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/compatibility/paperclip.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/locale/en.yml create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/mount.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/orm/activerecord.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mime_types.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mini_magick.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/rmagick.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/sanitized_file.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/abstract.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/file.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/fog.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/test/matchers.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/cache.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/callbacks.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/configuration.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/default_url.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/download.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/extension_whitelist.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/mountable.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/processing.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/proxy.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/remove.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/serialization.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/store.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/url.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/versions.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/validations/active_model.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/version.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/templates/uploader.rb create mode 100644 lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/uploader_generator.rb create mode 100644 lib/gemcache/ruby/1.9.1/specifications/carrierwave-0.6.2.gemspec diff --git a/THIRD-PARTY.md b/THIRD-PARTY.md index 09797cd73132..e5b46e420790 100644 --- a/THIRD-PARTY.md +++ b/THIRD-PARTY.md @@ -1032,6 +1032,7 @@ MIT * activeresource - Copyright (c) 2006-2011 David Heinemeier Hansson * activesupport - Copyright (c) 2005-2011 David Heinemeier Hansson * authlogic - Copyright (c) 2011 Ben Johnson of Binary Logic + * carrierwave - Copyright (c) 2008-2012 Jonas Nicklas * chunky_png - Copyright (c) 2010 Willem van Bergen * daemons - Copyright (c) 2005-2012 Thomas Uehlinger * diff-lcs - Copyright 2004–2011 Austin Ziegler diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/README.md b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/README.md new file mode 100644 index 000000000000..1c5b549b5158 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/README.md @@ -0,0 +1,785 @@ +# CarrierWave + +This gem provides a simple and extremely flexible way to upload files from Ruby applications. +It works well with Rack based web applications, such as Ruby on Rails. + +[![Build Status](https://secure.travis-ci.org/jnicklas/carrierwave.png)](http://travis-ci.org/jnicklas/carrierwave) + +## Information + +* RDoc documentation [available on RubyDoc.info](http://rubydoc.info/gems/carrierwave/frames) +* Source code [available on GitHub](http://github.com/jnicklas/carrierwave) +* More information, known limitations, and how-tos [available on the wiki](https://github.com/jnicklas/carrierwave/wiki) + +## Getting Help + +* Please ask the [Google Group](http://groups.google.com/group/carrierwave) for help if you have any questions. +* Please report bugs on the [issue tracker](http://github.com/jnicklas/carrierwave/issues) but read the "getting help" section in the wiki first. + +## Installation + +Install the latest stable release: + + [sudo] gem install carrierwave + +In Rails, add it to your Gemfile: + +```ruby +gem 'carrierwave' +``` + +Note that CarrierWave is not compatible with Rails 2 as of version 0.5. If you want to use +Rails 2, please use the 0.4-stable branch on GitHub. + +## Getting Started + +Start off by generating an uploader: + + rails generate uploader Avatar + +this should give you a file in: + + app/uploaders/avatar_uploader.rb + +Check out this file for some hints on how you can customize your uploader. It +should look something like this: + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + storage :file +end +``` + +You can use your uploader class to store and retrieve files like this: + +```ruby +uploader = AvatarUploader.new + +uploader.store!(my_file) + +uploader.retrieve_from_store!('my_file.png') +``` + +CarrierWave gives you a `store` for permanent storage, and a `cache` for +temporary storage. You can use different stores, including filesystem +and cloud storage. + +Most of the time you are going to want to use CarrierWave together with an ORM. +It is quite simple to mount uploaders on columns in your model, so you can +simply assign files and get going: + +### ActiveRecord + +Make sure you are loading CarrierWave after loading your ORM, otherwise you'll +need to require the relevant extension manually, e.g.: + +```ruby +require 'carrierwave/orm/activerecord' +``` + +Add a string column to the model you want to mount the uploader on: + +```ruby +add_column :users, :avatar, :string +``` + +Open your model file and mount the uploader: + +```ruby +class User < ActiveRecord::Base + mount_uploader :avatar, AvatarUploader +end +``` + +Now you can cache files by assigning them to the attribute, they will +automatically be stored when the record is saved. + +```ruby +u = User.new +u.avatar = params[:file] +u.avatar = File.open('somewhere') +u.save! +u.avatar.url # => '/url/to/file.png' +u.avatar.current_path # => 'path/to/file.png' +u.avatar.identifier # => 'file.png' +``` + +### DataMapper, Mongoid, Sequel + +Other ORM support has been extracted into separate gems: + +* [carrierwave-datamapper](https://github.com/jnicklas/carrierwave-datamapper) +* [carrierwave-mongoid](https://github.com/jnicklas/carrierwave-mongoid) +* [carrierwave-sequel](https://github.com/jnicklas/carrierwave-sequel) + +There are more extensions listed in [the wiki](https://github.com/jnicklas/carrierwave/wiki) + +## Changing the storage directory + +In order to change where uploaded files are put, just override the `store_dir` +method: + +```ruby +class MyUploader < CarrierWave::Uploader::Base + def store_dir + 'public/my/upload/directory' + end +end +``` + +This works for the file storage as well as Amazon S3 and Rackspace Cloud Files. +Define `store_dir` as `nil` if you'd like to store files at the root level. + +## Securing uploads + +Certain file might be dangerous if uploaded to the wrong location, such as php +files or other script files. CarrierWave allows you to specify a white-list of +allowed extensions. + +If you're mounting the uploader, uploading a file with the wrong extension will +make the record invalid instead. Otherwise, an error is raised. + +```ruby +class MyUploader < CarrierWave::Uploader::Base + def extension_white_list + %w(jpg jpeg gif png) + end +end +``` + +### Filenames and unicode chars + +Another security issue you should care for is the file names (see +[Ruby On Rails Security Guide](http://guides.rubyonrails.org/security.html#file-uploads)). +By default, CarrierWave provides only English letters, arabic numerals and '-+_.' symbols as +white-listed characters in the file name. If you want to support local scripts (Cyrillic letters, letters with diacritics and so on), you +have to override `sanitize_regexp` method. It should return regular expression which would match +all *non*-allowed symbols. + +With Ruby 1.9 and higher you can simply write (as it has [Oniguruma](http://oniguruma.rubyforge.org/oniguruma/) +built-in): + +```ruby + CarrierWave::SanitizedFile.sanitize_regexp = /[^[:word:]\.\-\+]/ +``` + +With Ruby 1.8 you have to manually specify all character ranges. For example, for files which may +contain Russian letters: + +```ruby + CarrierWave::SanitizedFile.sanitize_regexp = /[^a-zA-Zа-яА-ЯёЁ0-9\.\-\+_]/u +``` + +Also make sure that allowing non-latin characters won't cause a compatibility issue with a third-party +plugins or client-side software. + +## Setting the content type + +If you care about the content type of your files and notice that it's not being set +as expected, you can configure your uploaders to use `CarrierWave::MimeTypes`. +This adds a dependency on the [mime-types](http://rubygems.org/gems/mime-types) gem, +but is recommended when using fog, and fog already has a dependency on mime-types. + +```ruby +require 'carrierwave/processing/mime_types' + +class MyUploader < CarrierWave::Uploader::Base + include CarrierWave::MimeTypes + + process :set_content_type +end +``` + +## Adding versions + +Often you'll want to add different versions of the same file. The classic +example is image thumbnails. There is built in support for this: + +```ruby +class MyUploader < CarrierWave::Uploader::Base + include CarrierWave::RMagick + + process :resize_to_fit => [800, 800] + + version :thumb do + process :resize_to_fill => [200,200] + end + +end +``` + +When this uploader is used, an uploaded image would be scaled to be no larger +than 800 by 800 pixels. A version called thumb is then created, which is scaled +and cropped to exactly 200 by 200 pixels. The uploader could be used like this: + +```ruby +uploader = AvatarUploader.new +uploader.store!(my_file) # size: 1024x768 + +uploader.url # => '/url/to/my_file.png' # size: 800x600 +uploader.thumb.url # => '/url/to/thumb_my_file.png' # size: 200x200 +``` + +One important thing to remember is that process is called *before* versions are +created. This can cut down on processing cost. + +It is possible to nest versions within versions: + +```ruby +class MyUploader < CarrierWave::Uploader::Base + + version :animal do + version :human + version :monkey + version :llama + end +end +``` + +### Conditional versions + +Occasionally you want to restrict the creation of versions on certain +properties within the model or based on the picture itself. + +```ruby +class MyUploader < CarrierWave::Uploader::Base + + version :human, :if => :is_human? + version :monkey, :if => :is_monkey? + version :banner, :if => :is_landscape? + +protected + + def is_human? picture + model.can_program?(:ruby) + end + + def is_monkey? picture + model.favorite_food == 'banana' + end + + def is_landscape? picture + image = MiniMagick::Image.open(picture.path) + image[:width] > image[:height] + end + +end +``` + +The `model` variable points to the instance object the uploader is attached to. + +### Create versions from existing versions + +For performance reasons, it is often useful to create versions from existing ones +instead of using the original file. If your uploader generates several versions +where the next is smaller than the last, it will take less time to generate from +a smaller, already processed image. + +```ruby +class MyUploader < CarrierWave::Uploader::Base + + version :thumb do + process resize_to_fill: [280, 280] + end + + version :small_thumb, :from_version => :thumb do + process resize_to_fill: [20, 20] + end + +end +``` + +The option `:from_version` uses the file cached in the `:thumb` version instead +of the original version, potentially resulting in faster processing. + +## Making uploads work across form redisplays + +Often you'll notice that uploaded files disappear when a validation fails. +CarrierWave has a feature that makes it easy to remember the uploaded file even +in that case. Suppose your `user` model has an uploader mounted on `avatar` +file, just add a hidden field called `avatar_cache`. In Rails, this would look +like this: + +```erb +<%= form_for @user, :html => {:multipart => true} do |f| %> +

+ + <%= f.file_field :avatar %> + <%= f.hidden_field :avatar_cache %> +

+<% end %> +```` + +It might be a good idea to show the user that a file has been uploaded, in the +case of images, a small thumbnail would be a good indicator: + +```erb +<%= form_for @user, :html => {:multipart => true} do |f| %> +

+ + <%= image_tag(@user.avatar_url) if @user.avatar? %> + <%= f.file_field :avatar %> + <%= f.hidden_field :avatar_cache %> +

+<% end %> +``` + +## Removing uploaded files + +If you want to remove a previously uploaded file on a mounted uploader, you can +easily add a checkbox to the form which will remove the file when checked. + +```erb +<%= form_for @user, :html => {:multipart => true} do |f| %> +

+ + <%= image_tag(@user.avatar_url) if @user.avatar? %> + <%= f.file_field :avatar %> +

+ +

+ +

+<% end %> +``` + +If you want to remove the file manually, you can call remove_avatar!. + +## Uploading files from a remote location + +Your users may find it convenient to upload a file from a location on the Internet +via a URL. CarrierWave makes this simple, just add the appropriate attribute to your +form and you're good to go: + +```erb +<%= form_for @user, :html => {:multipart => true} do |f| %> +

+ + <%= image_tag(@user.avatar_url) if @user.avatar? %> + <%= f.text_field :remote_avatar_url %> +

+<% end %> +``` + +## Providing a default URL + +In many cases, especially when working with images, it might be a good idea to +provide a default url, a fallback in case no file has been uploaded. You can do +this easily by overriding the `default_url` method in your uploader: + +```ruby +class MyUploader < CarrierWave::Uploader::Base + def default_url + "/images/fallback/" + [version_name, "default.png"].compact.join('_') + end +end +``` + +## Recreating versions + +You might come to a situation where you want to retroactively change a version +or add a new one. You can use the recreate_versions! method to recreate the +versions from the base file. This uses a naive approach which will re-upload and +process all versions. + +```ruby +instance = MyUploader.new +instance.recreate_versions! +``` + +Or on a mounted uploader: + +```ruby +User.all.each do |user| + user.avatar.recreate_versions! +end +``` + +## Configuring CarrierWave + +CarrierWave has a broad range of configuration options, which you can configure, +both globally and on a per-uploader basis: + +```ruby +CarrierWave.configure do |config| + config.permissions = 0666 + config.storage = :file +end +``` + +Or alternatively: + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + permissions 0777 +end +``` + +If you're using Rails, create an initializer for this: + +```ruby +config/initializers/carrierwave.rb +``` + +## Testing with CarrierWave + +It's a good idea to test you uploaders in isolation. In order to speed up your +tests, it's recommended to switch off processing in your tests, and to use the +file storage. In Rails you could do that by adding an initializer with: + +```ruby +if Rails.env.test? or Rails.env.cucumber? + CarrierWave.configure do |config| + config.storage = :file + config.enable_processing = false + end +end +``` + +If you need to test your processing, you should test it in isolation, and enable +processing only for those tests that need it. + +CarrierWave comes with some RSpec matchers which you may find useful: + +```ruby +require 'carrierwave/test/matchers' + +describe MyUploader do + include CarrierWave::Test::Matchers + + before do + MyUploader.enable_processing = true + @uploader = MyUploader.new(@user, :avatar) + @uploader.store!(File.open(path_to_file)) + end + + after do + MyUploader.enable_processing = false + @uploader.remove! + end + + context 'the thumb version' do + it "should scale down a landscape image to be exactly 64 by 64 pixels" do + @uploader.thumb.should have_dimensions(64, 64) + end + end + + context 'the small version' do + it "should scale down a landscape image to fit within 200 by 200 pixels" do + @uploader.small.should be_no_larger_than(200, 200) + end + end + + it "should make the image readable only to the owner and not executable" do + @uploader.should have_permissions(0600) + end +end +``` + +Setting the enable_processing flag on an uploader will prevent any of the versions from processing as well. +Processing can be enabled for a single version by setting the processing flag on the version like so: + +```ruby +@uploader.thumb.enable_processing = true +``` + +## Using Amazon S3 + +[Fog](http://github.com/fog/fog) is used to support Amazon S3. Ensure you have it in your Gemfile: + +```ruby +gem "fog", "~> 1.3.1" +``` + +You'll need to provide your fog_credentials and a fog_directory (also known as a bucket) in an initializer. +For the sake of performance it is assumed that the directory already exists, so please create it if need be. +You can also pass in additional options, as documented fully in lib/carrierwave/storage/fog.rb. Here's a full example: + +```ruby +CarrierWave.configure do |config| + config.fog_credentials = { + :provider => 'AWS', # required + :aws_access_key_id => 'xxx', # required + :aws_secret_access_key => 'yyy', # required + :region => 'eu-west-1' # optional, defaults to 'us-east-1' + } + config.fog_directory = 'name_of_directory' # required + config.fog_host = 'https://assets.example.com' # optional, defaults to nil + config.fog_public = false # optional, defaults to true + config.fog_attributes = {'Cache-Control'=>'max-age=315576000'} # optional, defaults to {} +end +``` + +In your uploader, set the storage to :fog + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + storage :fog +end +``` + +That's it! You can still use the `CarrierWave::Uploader#url` method to return the url to the file on Amazon S3. + +## Using Rackspace Cloud Files + +[Fog](http://github.com/fog/fog) is used to support Rackspace Cloud Files. Ensure you have it in your Gemfile: + +```ruby +gem "fog", "~> 1.3.1" +``` + +You'll need to configure a directory (also known as a container), username and API key in the initializer. +For the sake of performance it is assumed that the directory already exists, so please create it if need be. + +```ruby +CarrierWave.configure do |config| + config.fog_credentials = { + :provider => 'Rackspace', + :rackspace_username => 'xxxxxx', + :rackspace_api_key => 'yyyyyy' + } + config.fog_directory = 'name_of_directory' +end +``` + +You can optionally include your CDN host name in the configuration. +This is *highly* recommended, as without it every request requires a lookup +of this information. + +```ruby +config.fog_host = "http://c000000.cdn.rackspacecloud.com" +``` + +In your uploader, set the storage to :fog + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + storage :fog +end +``` + +That's it! You can still use the `CarrierWave::Uploader#url` method to return +the url to the file on Rackspace Cloud Files. + +## Using Google Storage for Developers + +[Fog](http://github.com/fog/fog) is used to support Google Storage for Developers. Ensure you have it in your Gemfile: + +```ruby +gem "fog", "~> 1.3.1" +``` + +You'll need to configure a directory (also known as a bucket), access key id and secret access key in the initializer. +For the sake of performance it is assumed that the directory already exists, so please create it if need be. + +```ruby +CarrierWave.configure do |config| + config.fog_credentials = { + :provider => 'Google', + :google_storage_access_key_id => 'xxxxxx', + :google_storage_secret_access_key => 'yyyyyy' + } + config.fog_directory = 'name_of_directory' +end +``` + +In your uploader, set the storage to :fog + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + storage :fog +end +``` + +That's it! You can still use the `CarrierWave::Uploader#url` method to return +the url to the file on Google. + +## Dynamic Fog Host + +The `fog_host` config property can be assigned a proc (or anything that responds to `call`) for generating the host dynamically. The proc-compliant object gets an instance of the current `CarrierWave::Storage::Fog::File` as its only argument. + +```ruby +CarrierWave.configure do |config| + config.fog_host = proc do |file| + identifier = # some logic + "http://#{identifier}.cdn.rackspacecloud.com" + end +end +``` + +## Using RMagick + +If you're uploading images, you'll probably want to manipulate them in some way, +you might want to create thumbnail images for example. CarrierWave comes with a +small library to make manipulating images with RMagick easier, you'll need to +include it in your Uploader: + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + include CarrierWave::RMagick +end +``` + +The RMagick module gives you a few methods, like +`CarrierWave::RMagick#resize_to_fill` which manipulate the image file in some +way. You can set a `process` callback, which will call that method any time a +file is uploaded. +There is a demonstration of convert here. +Convert will only work if the file has the same file extension, thus the use of the filename method. + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + include CarrierWave::RMagick + + process :resize_to_fill => [200, 200] + process :convert => 'png' + + def filename + super.chomp(File.extname(super)) + '.png' + end +end +``` + +Check out the manipulate! method, which makes it easy for you to write your own +manipulation methods. + +## Using MiniMagick + +MiniMagick is similar to RMagick but performs all the operations using the 'mogrify' +command which is part of the standard ImageMagick kit. This allows you to have the power +of ImageMagick without having to worry about installing all the RMagick libraries. + +See the MiniMagick site for more details: + +http://github.com/probablycorey/mini_magick + +And the ImageMagick command line options for more for whats on offer: + +http://www.imagemagick.org/script/command-line-options.php + +Currently, the MiniMagick carrierwave processor provides exactly the same methods as +for the RMagick processor. + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + include CarrierWave::MiniMagick + + process :resize_to_fill => [200, 200] +end +``` + +## Migrating from Paperclip + +If you are using Paperclip, you can use the provided compatibility module: + +```ruby +class AvatarUploader < CarrierWave::Uploader::Base + include CarrierWave::Compatibility::Paperclip +end +``` + +See the documentation for `CarrierWave::Compatibility::Paperclip` for more +details. + +Be sure to use mount_on to specify the correct column: + +```ruby +mount_uploader :avatar, AvatarUploader, :mount_on => :avatar_file_name +``` + +Unfortunately attachment_fu differs too much in philosophy for there to be a +sensible compatibility mode. Patches for migrating from other solutions will be +happily accepted. + +## i18n + +The Active Record validations use the Rails i18n framework. Add these keys to +your translations file: + +```yaml +errors: + messages: + carrierwave_processing_error: 'Cannot resize image.' + carrierwave_integrity_error: 'Not an image.' +``` + +## Large files + +By default, CarrierWave copies an uploaded file twice, first copying the file into the cache, then +copying the file into the store. For large files, this can be prohibitively time consuming. + +You may change this behavior by overriding either or both of the `move_to_cache` and +`move_to_store` methods: + +```ruby +class MyUploader < CarrierWave::Uploader::Base + def move_to_cache + true + end + def move_to_store + true + end +end +``` + +When the `move_to_cache` and/or `move_to_store` methods return true, files will be moved (instead of copied) to the cache and store respectively. + +This has only been tested with the local filesystem store. + +## Contributing to CarrierWave + +CarrierWave thrives on a large number of [contributors](https://github.com/jnicklas/carrierwave/contributors), +and pull requests are very welcome. Before submitting a pull request, please make sure that your changes are well tested. + +You'll need to install bundler and the gem dependencies: + + gem install bundler + bundle install + +You should now be able to run the local tests: + + bundle exec rake + +You can also run the remote specs by creating a ~/.fog file: + +```yaml +:carrierwave: + :aws_access_key_id: xxx + :aws_secret_access_key: yyy + :rackspace_username: xxx + :rackspace_api_key: yyy + :google_storage_access_key_id: xxx + :google_storage_secret_access_key: yyy +``` + +You should now be able to run the remote tests: + + REMOTE=true bundle exec rake + +Please test with the latest Ruby 1.8.x and 1.9.x versions using RVM if possible. + +## License + +Copyright (c) 2008-2012 Jonas Nicklas + +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. diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave.rb new file mode 100644 index 000000000000..3973c689de11 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave.rb @@ -0,0 +1,111 @@ +# encoding: utf-8 + +require 'fileutils' +require 'active_support/core_ext/object/blank' +require 'active_support/core_ext/class/attribute' + +require 'active_support/concern' + +module CarrierWave + + class << self + attr_accessor :root, :base_path + + def configure(&block) + CarrierWave::Uploader::Base.configure(&block) + end + + def clean_cached_files! + CarrierWave::Uploader::Base.clean_cached_files! + end + end + + class UploadError < StandardError; end + class IntegrityError < UploadError; end + class InvalidParameter < UploadError; end + class ProcessingError < UploadError; end + class DownloadError < UploadError; end + + autoload :SanitizedFile, 'carrierwave/sanitized_file' + autoload :Mount, 'carrierwave/mount' + autoload :RMagick, 'carrierwave/processing/rmagick' + autoload :ImageScience, 'carrierwave/processing/image_science' + autoload :MiniMagick, 'carrierwave/processing/mini_magick' + autoload :MimeTypes, 'carrierwave/processing/mime_types' + autoload :VERSION, 'carrierwave/version' + + module Storage + autoload :Abstract, 'carrierwave/storage/abstract' + autoload :File, 'carrierwave/storage/file' + autoload :Fog, 'carrierwave/storage/fog' + end + + module Uploader + autoload :Base, 'carrierwave/uploader' + autoload :Cache, 'carrierwave/uploader/cache' + autoload :Store, 'carrierwave/uploader/store' + autoload :Download, 'carrierwave/uploader/download' + autoload :Callbacks, 'carrierwave/uploader/callbacks' + autoload :Processing, 'carrierwave/uploader/processing' + autoload :Versions, 'carrierwave/uploader/versions' + autoload :Remove, 'carrierwave/uploader/remove' + autoload :ExtensionWhitelist, 'carrierwave/uploader/extension_whitelist' + autoload :DefaultUrl, 'carrierwave/uploader/default_url' + autoload :Proxy, 'carrierwave/uploader/proxy' + autoload :Url, 'carrierwave/uploader/url' + autoload :Mountable, 'carrierwave/uploader/mountable' + autoload :Configuration, 'carrierwave/uploader/configuration' + autoload :Serialization, 'carrierwave/uploader/serialization' + end + + module Compatibility + autoload :Paperclip, 'carrierwave/compatibility/paperclip' + end + + module Test + autoload :Matchers, 'carrierwave/test/matchers' + end + +end + +if defined?(Merb) + + CarrierWave.root = Merb.dir_for(:public) + Merb::BootLoader.before_app_loads do + # Setup path for uploaders and load all of them before classes are loaded + Merb.push_path(:uploaders, Merb.root / 'app' / 'uploaders', '*.rb') + Dir.glob(File.join(Merb.load_paths[:uploaders])).each {|f| require f } + end + +elsif defined?(Rails) + + module CarrierWave + class Railtie < Rails::Railtie + initializer "carrierwave.setup_paths" do + CarrierWave.root = Rails.root.join(Rails.public_path).to_s + CarrierWave.base_path = ENV['RAILS_RELATIVE_URL_ROOT'] + end + + initializer "carrierwave.active_record" do + ActiveSupport.on_load :active_record do + require 'carrierwave/orm/activerecord' + end + end + end + end + +elsif defined?(Sinatra) + if defined?(Padrino) + CarrierWave.root = File.join(PADRINO_ROOT, "public") + else + + CarrierWave.root = if Sinatra::Application.respond_to?(:public_folder) + # Sinatra >= 1.3 + Sinatra::Application.public_folder + else + # Sinatra < 1.3 + Sinatra::Application.public + end + end + +end diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/compatibility/paperclip.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/compatibility/paperclip.rb new file mode 100644 index 000000000000..4cc4cdbce9ec --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/compatibility/paperclip.rb @@ -0,0 +1,95 @@ +# encoding: utf-8 + +module CarrierWave + module Compatibility + + ## + # Mix this module into an Uploader to make it mimic Paperclip's storage paths + # This will make your Uploader use the same default storage path as paperclip + # does. If you need to override it, you can override the +paperclip_path+ method + # and provide a Paperclip style path: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::Compatibility::Paperclip + # + # def paperclip_path + # ":rails_root/public/uploads/:id/:attachment/:style_:basename.:extension" + # end + # end + # + # --- + # + # This file contains code taken from Paperclip + # + # LICENSE + # + # The MIT License + # + # Copyright (c) 2008 Jon Yurek and thoughtbot, inc. + # + # 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. + # + module Paperclip + + def store_path(for_file=filename) + path = paperclip_path + path ||= File.join(*[store_dir, paperclip_style.to_s, for_file].compact) + interpolate_paperclip_path(path, for_file) + end + + def store_dir + ":rails_root/public/system/:attachment/:id" + end + + def paperclip_default_style + :original + end + + def paperclip_path + end + + def paperclip_style + version_name || paperclip_default_style + end + + private + + def interpolate_paperclip_path(path, filename) + mappings.inject(path) do |agg, pair| + agg.gsub(":#{pair[0]}") { pair[1].call(self, filename).to_s } + end + end + + def mappings + [ + [:rails_root , lambda{|u, f| Rails.root }], + [:rails_env , lambda{|u, f| Rails.env }], + [:class , lambda{|u, f| u.model.class.name.underscore.pluralize}], + [:id_partition , lambda{|u, f| ("%09d" % u.model.id).scan(/\d{3}/).join("/")}], + [:id , lambda{|u, f| u.model.id }], + [:attachment , lambda{|u, f| u.mounted_as.to_s.downcase.pluralize }], + [:style , lambda{|u, f| u.paperclip_style }], + [:basename , lambda{|u, f| f.gsub(/#{File.extname(f)}$/, "") }], + [:extension , lambda{|u, f| File.extname(f).gsub(/^\.+/, "")}] + ] + end + + end # Paperclip + end # Compatibility +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/locale/en.yml b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/locale/en.yml new file mode 100644 index 000000000000..f1290dcf53b7 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/locale/en.yml @@ -0,0 +1,9 @@ +en: + errors: + messages: + carrierwave_processing_error: failed to be processed + carrierwave_integrity_error: is not of an allowed file type + extension_white_list_error: "You are not allowed to upload %{extension} files, allowed types: %{allowed_types}" + rmagick_processing_error: "Failed to manipulate with rmagick, maybe it is not an image? Original Error: %{e}" + mime_types_processing_error: "Failed to process file with MIME::Types, maybe not valid content-type? Original Error: %{e}" + mini_magick_processing_error: "Failed to manipulate with MiniMagick, maybe it is not an image? Original Error: %{e}" \ No newline at end of file diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/mount.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/mount.rb new file mode 100644 index 000000000000..806a5662e7be --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/mount.rb @@ -0,0 +1,382 @@ +# encoding: utf-8 + +module CarrierWave + + ## + # If a Class is extended with this module, it gains the mount_uploader + # method, which is used for mapping attributes to uploaders and allowing + # easy assignment. + # + # You can use mount_uploader with pretty much any class, however it is + # intended to be used with some kind of persistent storage, like an ORM. + # If you want to persist the uploaded files in a particular Class, it + # needs to implement a `read_uploader` and a `write_uploader` method. + # + module Mount + + ## + # === Returns + # + # [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns + # + def uploaders + @uploaders ||= {} + @uploaders = superclass.uploaders.merge(@uploaders) if superclass.respond_to?(:uploaders) + @uploaders + end + + def uploader_options + @uploader_options ||= {} + @uploader_options = superclass.uploader_options.merge(@uploader_options) if superclass.respond_to?(:uploader_options) + @uploader_options + end + + ## + # Return a particular option for a particular uploader + # + # === Parameters + # + # [column (Symbol)] The column the uploader is mounted at + # [option (Symbol)] The option, e.g. validate_integrity + # + # === Returns + # + # [Object] The option value + # + def uploader_option(column, option) + if uploader_options[column].has_key?(option) + uploader_options[column][option] + else + uploaders[column].send(option) + end + end + + ## + # Mounts the given uploader on the given column. This means that assigning + # and reading from the column will upload and retrieve files. Supposing + # that a User class has an uploader mounted on image, you can assign and + # retrieve files like this: + # + # @user.image # => + # @user.image.store!(some_file_object) + # + # @user.image.url # => '/some_url.png' + # + # It is also possible (but not recommended) to ommit the uploader, which + # will create an anonymous uploader class. + # + # Passing a block makes it possible to customize the uploader. This can be + # convenient for brevity, but if there is any significatnt logic in the + # uploader, you should do the right thing and have it in its own file. + # + # === Added instance methods + # + # Supposing a class has used +mount_uploader+ to mount an uploader on a column + # named +image+, in that case the following methods will be added to the class: + # + # [image] Returns an instance of the uploader only if anything has been uploaded + # [image=] Caches the given file + # + # [image_url] Returns the url to the uploaded file + # + # [image_cache] Returns a string that identifies the cache location of the file + # [image_cache=] Retrieves the file from the cache based on the given cache name + # + # [remote_image_url] Returns previously cached remote url + # [remote_image_url=] Retrieve the file from the remote url + # + # [remove_image] An attribute reader that can be used with a checkbox to mark a file for removal + # [remove_image=] An attribute writer that can be used with a checkbox to mark a file for removal + # [remove_image?] Whether the file should be removed when store_image! is called. + # + # [store_image!] Stores a file that has been assigned with +image=+ + # [remove_image!] Removes the uploaded file from the filesystem. + # + # [image_integrity_error] Returns an error object if the last file to be assigned caused an integrity error + # [image_processing_error] Returns an error object if the last file to be assigned caused a processing error + # + # [write_image_identifier] Uses the write_uploader method to set the identifier. + # [image_identifier] Reads out the identifier of the file + # + # === Parameters + # + # [column (Symbol)] the attribute to mount this uploader on + # [uploader (CarrierWave::Uploader)] the uploader class to mount + # [options (Hash{Symbol => Object})] a set of options + # [&block (Proc)] customize anonymous uploaders + # + # === Options + # + # [:mount_on => Symbol] if the name of the column to be serialized to differs you can override it using this option + # [:ignore_integrity_errors => Boolean] if set to true, integrity errors will result in caching failing silently + # [:ignore_processing_errors => Boolean] if set to true, processing errors will result in caching failing silently + # + # === Examples + # + # Mounting uploaders on different columns. + # + # class Song + # mount_uploader :lyrics, LyricsUploader + # mount_uploader :alternative_lyrics, LyricsUploader + # mount_uploader :file, SongUploader + # end + # + # This will add an anonymous uploader with only the default settings: + # + # class Data + # mount_uploader :csv + # end + # + # this will add an anonymous uploader overriding the store_dir: + # + # class Product + # mount_uploader :blueprint do + # def store_dir + # 'blueprints' + # end + # end + # end + # + def mount_uploader(column, uploader=nil, options={}, &block) + if block_given? + uploader = Class.new(uploader || CarrierWave::Uploader::Base) + uploader.class_eval(&block) + uploader.recursively_apply_block_to_versions(&block) + else + uploader ||= Class.new(CarrierWave::Uploader::Base) + end + + uploaders[column.to_sym] = uploader + uploader_options[column.to_sym] = options + + include CarrierWave::Mount::Extension + + # Make sure to write over accessors directly defined on the class. + # Simply super to the included module below. + class_eval <<-RUBY, __FILE__, __LINE__+1 + def #{column}; super; end + def #{column}=(new_file); super; end + RUBY + + # Mixing this in as a Module instead of class_evaling directly, so we + # can maintain the ability to super to any of these methods from within + # the class. + mod = Module.new + include mod + mod.class_eval <<-RUBY, __FILE__, __LINE__+1 + + def #{column} + _mounter(:#{column}).uploader + end + + def #{column}=(new_file) + _mounter(:#{column}).cache(new_file) + end + + def #{column}? + !_mounter(:#{column}).blank? + end + + def #{column}_url(*args) + _mounter(:#{column}).url(*args) + end + + def #{column}_cache + _mounter(:#{column}).cache_name + end + + def #{column}_cache=(cache_name) + _mounter(:#{column}).cache_name = cache_name + end + + def remote_#{column}_url + _mounter(:#{column}).remote_url + end + + def remote_#{column}_url=(url) + _mounter(:#{column}).remote_url = url + end + + def remove_#{column} + _mounter(:#{column}).remove + end + + def remove_#{column}! + _mounter(:#{column}).remove! + end + + def remove_#{column}=(value) + _mounter(:#{column}).remove = value + end + + def remove_#{column}? + _mounter(:#{column}).remove? + end + + def store_#{column}! + _mounter(:#{column}).store! + end + + def #{column}_integrity_error + _mounter(:#{column}).integrity_error + end + + def #{column}_processing_error + _mounter(:#{column}).processing_error + end + + def write_#{column}_identifier + _mounter(:#{column}).write_identifier + end + + def #{column}_identifier + _mounter(:#{column}).identifier + end + + def store_previous_model_for_#{column} + serialization_column = _mounter(:#{column}).serialization_column + + if #{column}.remove_previously_stored_files_after_update && send(:"\#{serialization_column}_changed?") + @previous_model_for_#{column} ||= self.find_previous_model_for_#{column} + end + end + + def find_previous_model_for_#{column} + self.class.find(to_key.first) + end + + def remove_previously_stored_#{column} + if @previous_model_for_#{column} && @previous_model_for_#{column}.#{column}.path != #{column}.path + @previous_model_for_#{column}.#{column}.remove! + @previous_model_for_#{column} = nil + end + end + + RUBY + end + + module Extension + + ## + # overwrite this to read from a serialized attribute + # + def read_uploader(column); end + + ## + # overwrite this to write to a serialized attribute + # + def write_uploader(column, identifier); end + + private + + def _mounter(column) + # We cannot memoize in frozen objects :( + return Mounter.new(self, column) if frozen? + @_mounters ||= {} + @_mounters[column] ||= Mounter.new(self, column) + end + + end # Extension + + # this is an internal class, used by CarrierWave::Mount so that + # we don't pollute the model with a lot of methods. + class Mounter #:nodoc: + attr_reader :column, :record, :remote_url, :integrity_error, :processing_error + attr_accessor :remove + + def initialize(record, column, options={}) + @record = record + @column = column + @options = record.class.uploader_options[column] + end + + def write_identifier + if remove? + record.write_uploader(serialization_column, '') + elsif not uploader.identifier.blank? + record.write_uploader(serialization_column, uploader.identifier) + end + end + + def identifier + record.read_uploader(serialization_column) + end + + def uploader + @uploader ||= record.class.uploaders[column].new(record, column) + + if @uploader.blank? and not identifier.blank? + @uploader.retrieve_from_store!(identifier) + end + return @uploader + end + + def cache(new_file) + uploader.cache!(new_file) + @integrity_error = nil + @processing_error = nil + rescue CarrierWave::IntegrityError => e + @integrity_error = e + raise e unless option(:ignore_integrity_errors) + rescue CarrierWave::ProcessingError => e + @processing_error = e + raise e unless option(:ignore_processing_errors) + end + + def cache_name + uploader.cache_name + end + + def cache_name=(cache_name) + uploader.retrieve_from_cache!(cache_name) unless uploader.cached? + rescue CarrierWave::InvalidParameter + end + + def remote_url=(url) + @remote_url = url + uploader.download!(url) + end + + def store! + unless uploader.blank? + if remove? + uploader.remove! + else + uploader.store! + end + end + end + + def url(*args) + uploader.url(*args) + end + + def blank? + uploader.blank? + end + + def remove? + !remove.blank? and remove !~ /\A0|false$\z/ + end + + def remove! + uploader.remove! + end + + def serialization_column + option(:mount_on) || column + end + + attr_accessor :uploader_options + + private + + def option(name) + self.uploader_options ||= {} + self.uploader_options[name] ||= record.class.uploader_option(column, name) + end + + end # Mounter + + end # Mount +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/orm/activerecord.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/orm/activerecord.rb new file mode 100644 index 000000000000..2b8c07ddf07f --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/orm/activerecord.rb @@ -0,0 +1,66 @@ +# encoding: utf-8 + +require 'active_record' +require 'carrierwave/validations/active_model' + +module CarrierWave + module ActiveRecord + + include CarrierWave::Mount + + ## + # See +CarrierWave::Mount#mount_uploader+ for documentation + # + def mount_uploader(column, uploader=nil, options={}, &block) + super + + alias_method :read_uploader, :read_attribute + alias_method :write_uploader, :write_attribute + public :read_uploader + public :write_uploader + + include CarrierWave::Validations::ActiveModel + + validates_integrity_of column if uploader_option(column.to_sym, :validate_integrity) + validates_processing_of column if uploader_option(column.to_sym, :validate_processing) + + after_save :"store_#{column}!" + before_save :"write_#{column}_identifier" + after_destroy :"remove_#{column}!" + before_update :"store_previous_model_for_#{column}" + after_save :"remove_previously_stored_#{column}" + + class_eval <<-RUBY, __FILE__, __LINE__+1 + def #{column}=(new_file) + column = _mounter(:#{column}).serialization_column + send(:"\#{column}_will_change!") + super + end + + def remote_#{column}_url=(url) + column = _mounter(:#{column}).serialization_column + send(:"\#{column}_will_change!") + super + end + + def serializable_hash(options=nil) + hash = {} + + except = options && options[:except] && Array.wrap(options[:except]).map(&:to_s) + only = options && options[:only] && Array.wrap(options[:only]).map(&:to_s) + + self.class.uploaders.each do |column, uploader| + if (!only && !except) || (only && only.include?(column.to_s)) || (except && !except.include?(column.to_s)) + hash[column.to_s] = _mounter(:#{column}).uploader.serializable_hash + end + end + super(options).merge(hash) + end + RUBY + + end + + end # ActiveRecord +end # CarrierWave + +ActiveRecord::Base.extend CarrierWave::ActiveRecord diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mime_types.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mime_types.rb new file mode 100644 index 000000000000..d75e75465584 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mime_types.rb @@ -0,0 +1,58 @@ +require 'mime/types' + +module CarrierWave + + ## + # This module simplifies the use of the mime-types gem to intelligently + # guess and set the content-type of a file. If you want to use this, you'll + # need to require this file: + # + # require 'carrierwave/processing/mime_types' + # + # And then include it in your uploader: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::MimeTypes + # end + # + # You can now use the provided helper: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::MimeTypes + # + # process :set_content_type + # end + # + module MimeTypes + extend ActiveSupport::Concern + + module ClassMethods + def set_content_type(override=false) + process :set_content_type => override + end + end + + ## + # Changes the file content_type using the mime-types gem + # + # === Parameters + # + # [override (Boolean)] whether or not to override the file's content_type + # if it is already set and not a generic content-type, + # false by default + # + def set_content_type(override=false) + if override || file.content_type.blank? || file.content_type == 'application/octet-stream' + new_content_type = ::MIME::Types.type_for(file.original_filename).first.to_s + if file.respond_to?(:content_type=) + file.content_type = new_content_type + else + file.instance_variable_set(:@content_type, new_content_type) + end + end + rescue ::MIME::InvalidContentType => e + raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.mime_types_processing_error", :e => e) + end + + end # MimeTypes +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mini_magick.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mini_magick.rb new file mode 100644 index 000000000000..14baffc08ea7 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/mini_magick.rb @@ -0,0 +1,254 @@ +# encoding: utf-8 + +require 'mini_magick' + +module CarrierWave + + ## + # This module simplifies manipulation with MiniMagick by providing a set + # of convenient helper methods. If you want to use them, you'll need to + # require this file: + # + # require 'carrierwave/processing/mini_magick' + # + # And then include it in your uploader: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::MiniMagick + # end + # + # You can now use the provided helpers: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::MiniMagick + # + # process :resize_to_fit => [200, 200] + # end + # + # Or create your own helpers with the powerful manipulate! method. Check + # out the ImageMagick docs at http://www.imagemagick.org/script/command-line-options.php for more + # info + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::MiniMagick + # + # process :radial_blur => 10 + # + # def radial_blur(amount) + # manipulate! do |img| + # img.radial_blur(amount) + # img = yield(img) if block_given? + # img + # end + # end + # + # === Note + # + # MiniMagick is a mini replacement for RMagick that uses the command line + # tool "mogrify" for image manipulation. + # + # You can find more information here: + # + # http://mini_magick.rubyforge.org/ + # and + # http://github.com/probablycorey/mini_magick/ + # + # + module MiniMagick + extend ActiveSupport::Concern + + module ClassMethods + def convert(format) + process :convert => format + end + + def resize_to_limit(width, height) + process :resize_to_limit => [width, height] + end + + def resize_to_fit(width, height) + process :resize_to_fit => [width, height] + end + + def resize_to_fill(width, height, gravity='Center') + process :resize_to_fill => [width, height, gravity] + end + + def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity) + process :resize_and_pad => [width, height, background, gravity] + end + end + + ## + # Changes the image encoding format to the given format + # + # See http://www.imagemagick.org/script/command-line-options.php#format + # + # === Parameters + # + # [format (#to_s)] an abreviation of the format + # + # === Yields + # + # [MiniMagick::Image] additional manipulations to perform + # + # === Examples + # + # image.convert(:png) + # + def convert(format) + manipulate! do |img| + img.format(format.to_s.downcase) + img = yield(img) if block_given? + img + end + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the original aspect ratio. Will only resize the image if it is larger than the + # specified dimensions. The resulting image may be shorter or narrower than specified + # in the smaller dimension but will not be larger than the specified values. + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # + # === Yields + # + # [MiniMagick::Image] additional manipulations to perform + # + def resize_to_limit(width, height) + manipulate! do |img| + img.resize "#{width}x#{height}>" + img = yield(img) if block_given? + img + end + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the original aspect ratio. The image may be shorter or narrower than + # specified in the smaller dimension but will not be larger than the specified values. + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # + # === Yields + # + # [MiniMagick::Image] additional manipulations to perform + # + def resize_to_fit(width, height) + manipulate! do |img| + img.resize "#{width}x#{height}" + img = yield(img) if block_given? + img + end + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the aspect ratio of the original image. If necessary, crop the image in the + # larger dimension. + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # [gravity (String)] the current gravity suggestion (default: 'Center'; options: 'NorthWest', 'North', 'NorthEast', 'West', 'Center', 'East', 'SouthWest', 'South', 'SouthEast') + # + # === Yields + # + # [MiniMagick::Image] additional manipulations to perform + # + def resize_to_fill(width, height, gravity = 'Center') + manipulate! do |img| + cols, rows = img[:dimensions] + img.combine_options do |cmd| + if width != cols || height != rows + scale = [width/cols.to_f, height/rows.to_f].max + cols = (scale * (cols + 0.5)).round + rows = (scale * (rows + 0.5)).round + cmd.resize "#{cols}x#{rows}" + end + cmd.gravity gravity + cmd.background "rgba(255,255,255,0.0)" + cmd.extent "#{width}x#{height}" if cols != width || rows != height + end + img = yield(img) if block_given? + img + end + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the original aspect ratio. If necessary, will pad the remaining area + # with the given color, which defaults to transparent (for gif and png, + # white for jpeg). + # + # See http://www.imagemagick.org/script/command-line-options.php#gravity + # for gravity options. + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # [background (String, :transparent)] the color of the background as a hexcode, like "#ff45de" + # [gravity (String)] how to position the image + # + # === Yields + # + # [MiniMagick::Image] additional manipulations to perform + # + def resize_and_pad(width, height, background=:transparent, gravity='Center') + manipulate! do |img| + img.combine_options do |cmd| + cmd.thumbnail "#{width}x#{height}>" + if background == :transparent + cmd.background "rgba(255, 255, 255, 0.0)" + else + cmd.background background + end + cmd.gravity gravity + cmd.extent "#{width}x#{height}" + end + img = yield(img) if block_given? + img + end + end + + ## + # Manipulate the image with MiniMagick. This method will load up an image + # and then pass each of its frames to the supplied block. It will then + # save the image to disk. + # + # === Gotcha + # + # This method assumes that the object responds to +current_path+. + # Any class that this module is mixed into must have a +current_path+ method. + # CarrierWave::Uploader does, so you won't need to worry about this in + # most cases. + # + # === Yields + # + # [MiniMagick::Image] manipulations to perform + # + # === Raises + # + # [CarrierWave::ProcessingError] if manipulation failed. + # + def manipulate! + cache_stored_file! if !cached? + image = ::MiniMagick::Image.open(current_path) + image = yield(image) + image.write(current_path) + ::MiniMagick::Image.open(current_path) + rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e + raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e) + end + + end # MiniMagick +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/rmagick.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/rmagick.rb new file mode 100644 index 000000000000..2165bbcc1ed6 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/processing/rmagick.rb @@ -0,0 +1,284 @@ +# encoding: utf-8 + +unless defined? Magick + begin + require 'rmagick' + rescue LoadError + require 'RMagick' + rescue LoadError + puts "WARNING: Failed to require rmagick, image processing may fail!" + end +end + +module CarrierWave + + ## + # This module simplifies manipulation with RMagick by providing a set + # of convenient helper methods. If you want to use them, you'll need to + # require this file: + # + # require 'carrierwave/processing/rmagick' + # + # And then include it in your uploader: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::RMagick + # end + # + # You can now use the provided helpers: + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::RMagick + # + # process :resize_to_fit => [200, 200] + # end + # + # Or create your own helpers with the powerful manipulate! method. Check + # out the RMagick docs at http://www.imagemagick.org/RMagick/doc/ for more + # info + # + # class MyUploader < CarrierWave::Uploader::Base + # include CarrierWave::RMagick + # + # process :do_stuff => 10.0 + # + # def do_stuff(blur_factor) + # manipulate! do |img| + # img = img.sepiatone + # img = img.auto_orient + # img = img.radial_blur(blur_factor) + # end + # end + # end + # + # === Note + # + # You should be aware how RMagick handles memory. manipulate! takes care + # of freeing up memory for you, but for optimum memory usage you should + # use destructive operations as much as possible: + # + # DON'T DO THIS: + # img = img.resize_to_fit + # + # DO THIS INSTEAD: + # img.resize_to_fit! + # + # Read this for more information why: + # + # http://rubyforge.org/forum/forum.php?thread_id=1374&forum_id=1618 + # + module RMagick + extend ActiveSupport::Concern + + module ClassMethods + def convert(format) + process :convert => format + end + + def resize_to_limit(width, height) + process :resize_to_limit => [width, height] + end + + def resize_to_fit(width, height) + process :resize_to_fit => [width, height] + end + + def resize_to_fill(width, height, gravity=::Magick::CenterGravity) + process :resize_to_fill => [width, height, gravity] + end + + def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity) + process :resize_and_pad => [width, height, background, gravity] + end + end + + ## + # Changes the image encoding format to the given format + # + # See even http://www.imagemagick.org/RMagick/doc/magick.html#formats + # + # === Parameters + # + # [format (#to_s)] an abreviation of the format + # + # === Yields + # + # [Magick::Image] additional manipulations to perform + # + # === Examples + # + # image.convert(:png) + # + def convert(format) + manipulate!(:format => format) + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the original aspect ratio. Will only resize the image if it is larger than the + # specified dimensions. The resulting image may be shorter or narrower than specified + # in the smaller dimension but will not be larger than the specified values. + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # + # === Yields + # + # [Magick::Image] additional manipulations to perform + # + def resize_to_limit(width, height) + manipulate! do |img| + geometry = Magick::Geometry.new(width, height, 0, 0, Magick::GreaterGeometry) + new_img = img.change_geometry(geometry) do |new_width, new_height| + img.resize(new_width, new_height) + end + destroy_image(img) + new_img = yield(new_img) if block_given? + new_img + end + end + + ## + # From the RMagick documentation: "Resize the image to fit within the + # specified dimensions while retaining the original aspect ratio. The + # image may be shorter or narrower than specified in the smaller dimension + # but will not be larger than the specified values." + # + # See even http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fit + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # + # === Yields + # + # [Magick::Image] additional manipulations to perform + # + def resize_to_fit(width, height) + manipulate! do |img| + img.resize_to_fit!(width, height) + img = yield(img) if block_given? + img + end + end + + ## + # From the RMagick documentation: "Resize the image to fit within the + # specified dimensions while retaining the aspect ratio of the original + # image. If necessary, crop the image in the larger dimension." + # + # See even http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fill + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # + # === Yields + # + # [Magick::Image] additional manipulations to perform + # + def resize_to_fill(width, height, gravity=::Magick::CenterGravity) + manipulate! do |img| + img.crop_resized!(width, height, gravity) + img = yield(img) if block_given? + img + end + end + + ## + # Resize the image to fit within the specified dimensions while retaining + # the original aspect ratio. If necessary, will pad the remaining area + # with the given color, which defaults to transparent (for gif and png, + # white for jpeg). + # + # === Parameters + # + # [width (Integer)] the width to scale the image to + # [height (Integer)] the height to scale the image to + # [background (String, :transparent)] the color of the background as a hexcode, like "#ff45de" + # [gravity (Magick::GravityType)] how to position the image + # + # === Yields + # + # [Magick::Image] additional manipulations to perform + # + def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity) + manipulate! do |img| + img.resize_to_fit!(width, height) + new_img = ::Magick::Image.new(width, height) + if background == :transparent + filled = new_img.matte_floodfill(1, 1) + else + filled = new_img.color_floodfill(1, 1, ::Magick::Pixel.from_color(background)) + end + destroy_image(new_img) + filled.composite!(img, gravity, ::Magick::OverCompositeOp) + destroy_image(img) + filled = yield(filled) if block_given? + filled + end + end + + ## + # Manipulate the image with RMagick. This method will load up an image + # and then pass each of its frames to the supplied block. It will then + # save the image to disk. + # + # === Gotcha + # + # This method assumes that the object responds to +current_path+. + # Any class that this module is mixed into must have a +current_path+ method. + # CarrierWave::Uploader does, so you won't need to worry about this in + # most cases. + # + # === Yields + # + # [Magick::Image] manipulations to perform + # + # === Raises + # + # [CarrierWave::ProcessingError] if manipulation failed. + # + def manipulate!(options={}, &block) + cache_stored_file! if !cached? + image = ::Magick::Image.read(current_path) + + frames = if image.size > 1 + list = ::Magick::ImageList.new + image.each_with_index do |frame, index| + processed_frame = if block_given? + yield *[frame, index].take(block.arity) + else + frame + end + list << processed_frame if processed_frame + end + block_given? ? list : list.append(true) + else + frame = image.first + frame = yield( *[frame, 0].take(block.arity) ) if block_given? + frame + end + + if options[:format] + frames.write("#{options[:format]}:#{current_path}") + else + frames.write(current_path) + end + destroy_image(frames) + rescue ::Magick::ImageMagickError => e + raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.rmagick_processing_error", :e => e) + end + + private + + def destroy_image(image) + image.destroy! if image.respond_to?(:destroy!) + end + + end # RMagick +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/sanitized_file.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/sanitized_file.rb new file mode 100644 index 000000000000..ee901e2fa101 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/sanitized_file.rb @@ -0,0 +1,315 @@ +# encoding: utf-8 + +require 'pathname' +require 'active_support/core_ext/string/multibyte' + +module CarrierWave + + ## + # SanitizedFile is a base class which provides a common API around all + # the different quirky Ruby File libraries. It has support for Tempfile, + # File, StringIO, Merb-style upload Hashes, as well as paths given as + # Strings and Pathnames. + # + # It's probably needlessly comprehensive and complex. Help is appreciated. + # + class SanitizedFile + + attr_accessor :file + + class << self + attr_writer :sanitize_regexp + + def sanitize_regexp + @sanitize_regexp ||= /[^a-zA-Z0-9\.\-\+_]/ + end + end + + def initialize(file) + self.file = file + end + + ## + # Returns the filename as is, without sanizting it. + # + # === Returns + # + # [String] the unsanitized filename + # + def original_filename + return @original_filename if @original_filename + if @file and @file.respond_to?(:original_filename) + @file.original_filename + elsif path + File.basename(path) + end + end + + ## + # Returns the filename, sanitized to strip out any evil characters. + # + # === Returns + # + # [String] the sanitized filename + # + def filename + sanitize(original_filename) if original_filename + end + + alias_method :identifier, :filename + + ## + # Returns the part of the filename before the extension. So if a file is called 'test.jpeg' + # this would return 'test' + # + # === Returns + # + # [String] the first part of the filename + # + def basename + split_extension(filename)[0] if filename + end + + ## + # Returns the file extension + # + # === Returns + # + # [String] the extension + # + def extension + split_extension(filename)[1] if filename + end + + ## + # Returns the file's size. + # + # === Returns + # + # [Integer] the file's size in bytes. + # + def size + if is_path? + exists? ? File.size(path) : 0 + elsif @file.respond_to?(:size) + @file.size + elsif path + exists? ? File.size(path) : 0 + else + 0 + end + end + + ## + # Returns the full path to the file. If the file has no path, it will return nil. + # + # === Returns + # + # [String, nil] the path where the file is located. + # + def path + unless @file.blank? + if is_path? + File.expand_path(@file) + elsif @file.respond_to?(:path) and not @file.path.blank? + File.expand_path(@file.path) + end + end + end + + ## + # === Returns + # + # [Boolean] whether the file is supplied as a pathname or string. + # + def is_path? + !!((@file.is_a?(String) || @file.is_a?(Pathname)) && !@file.blank?) + end + + ## + # === Returns + # + # [Boolean] whether the file is valid and has a non-zero size + # + def empty? + @file.nil? || self.size.nil? || (self.size.zero? && ! self.exists?) + end + + ## + # === Returns + # + # [Boolean] Whether the file exists + # + def exists? + return File.exists?(self.path) if self.path + return false + end + + ## + # Returns the contents of the file. + # + # === Returns + # + # [String] contents of the file + # + def read + if is_path? + File.open(@file, "rb") {|file| file.read} + else + @file.rewind if @file.respond_to?(:rewind) + @file.read + end + end + + ## + # Moves the file to the given path + # + # === Parameters + # + # [new_path (String)] The path where the file should be moved. + # [permissions (Integer)] permissions to set on the file in its new location. + # + def move_to(new_path, permissions=nil) + return if self.empty? + new_path = File.expand_path(new_path) + + mkdir!(new_path) + if exists? + FileUtils.mv(path, new_path) unless new_path == path + else + File.open(new_path, "wb") { |f| f.write(read) } + end + chmod!(new_path, permissions) + self.file = new_path + self + end + + ## + # Creates a copy of this file and moves it to the given path. Returns the copy. + # + # === Parameters + # + # [new_path (String)] The path where the file should be copied to. + # [permissions (Integer)] permissions to set on the copy + # + # === Returns + # + # @return [CarrierWave::SanitizedFile] the location where the file will be stored. + # + def copy_to(new_path, permissions=nil) + return if self.empty? + new_path = File.expand_path(new_path) + + mkdir!(new_path) + if exists? + FileUtils.cp(path, new_path) unless new_path == path + else + File.open(new_path, "wb") { |f| f.write(read) } + end + chmod!(new_path, permissions) + self.class.new({:tempfile => new_path, :content_type => content_type}) + end + + ## + # Removes the file from the filesystem. + # + def delete + FileUtils.rm(self.path) if exists? + end + + ## + # Returns a File object, or nil if it does not exist. + # + # === Returns + # + # [File] a File object representing the SanitizedFile + # + def to_file + return @file if @file.is_a?(File) + File.open(path) if exists? + end + + ## + # Returns the content type of the file. + # + # === Returns + # + # [String] the content type of the file + # + def content_type + return @content_type if @content_type + @file.content_type.to_s.chomp if @file.respond_to?(:content_type) and @file.content_type + end + + ## + # Sets the content type of the file. + # + # === Returns + # + # [String] the content type of the file + # + def content_type=(type) + @content_type = type + end + + ## + # Used to sanitize the file name. Public to allow overriding for non-latin characters. + # + # === Returns + # + # [Regexp] the regexp for sanitizing the file name + # + def sanitize_regexp + CarrierWave::SanitizedFile.sanitize_regexp + end + + private + + def file=(file) + if file.is_a?(Hash) + @file = file["tempfile"] || file[:tempfile] + @original_filename = file["filename"] || file[:filename] + @content_type = file["content_type"] || file[:content_type] + else + @file = file + @original_filename = nil + @content_type = nil + end + end + + # create the directory if it doesn't exist + def mkdir!(path) + FileUtils.mkdir_p(File.dirname(path)) unless File.exists?(File.dirname(path)) + end + + def chmod!(path, permissions) + File.chmod(permissions, path) if permissions + end + + # Sanitize the filename, to prevent hacking + def sanitize(name) + name = name.gsub("\\", "/") # work-around for IE + name = File.basename(name) + name = name.gsub(sanitize_regexp,"_") + name = "_#{name}" if name =~ /\A\.+\z/ + name = "unnamed" if name.size == 0 + return name.mb_chars.to_s + end + + def split_extension(filename) + # regular expressions to try for identifying extensions + extension_matchers = [ + /\A(.+)\.(tar\.gz)\z/, # matches "something.tar.gz" + /\A(.+)\.([^\.]+)\z/ # matches "something.jpg" + ] + + extension_matchers.each do |regexp| + if filename =~ regexp + return $1, $2 + end + end + return filename, "" # In case we weren't able to split the extension + end + + end # SanitizedFile +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/abstract.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/abstract.rb new file mode 100644 index 000000000000..d047393bcc7d --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/abstract.rb @@ -0,0 +1,30 @@ +# encoding: utf-8 + +module CarrierWave + module Storage + + ## + # This file serves mostly as a specification for Storage engines. There is no requirement + # that storage engines must be a subclass of this class. + # + class Abstract + + attr_reader :uploader + + def initialize(uploader) + @uploader = uploader + end + + def identifier + uploader.filename + end + + def store!(file) + end + + def retrieve!(identifier) + end + + end # Abstract + end # Storage +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/file.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/file.rb new file mode 100644 index 000000000000..d5f46d353159 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/file.rb @@ -0,0 +1,56 @@ +# encoding: utf-8 + +module CarrierWave + module Storage + + ## + # File storage stores file to the Filesystem (surprising, no?). There's really not much + # to it, it uses the store_dir defined on the uploader as the storage location. That's + # pretty much it. + # + class File < Abstract + + ## + # Move the file to the uploader's store path. + # + # By default, store!() uses copy_to(), which operates by copying the file + # from the cache to the store, then deleting the file from the cache. + # If move_to_store() is overriden to return true, then store!() uses move_to(), + # which simply moves the file from cache to store. Useful for large files. + # + # === Parameters + # + # [file (CarrierWave::SanitizedFile)] the file to store + # + # === Returns + # + # [CarrierWave::SanitizedFile] a sanitized file + # + def store!(file) + path = ::File.expand_path(uploader.store_path, uploader.root) + if uploader.move_to_store + file.move_to(path, uploader.permissions) + else + file.copy_to(path, uploader.permissions) + end + end + + ## + # Retrieve the file from its store path + # + # === Parameters + # + # [identifier (String)] the filename of the file + # + # === Returns + # + # [CarrierWave::SanitizedFile] a sanitized file + # + def retrieve!(identifier) + path = ::File.expand_path(uploader.store_path(identifier), uploader.root) + CarrierWave::SanitizedFile.new(path) + end + + end # File + end # Storage +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/fog.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/fog.rb new file mode 100644 index 000000000000..8451b16d3b56 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/storage/fog.rb @@ -0,0 +1,358 @@ +# encoding: utf-8 + +begin + require 'fog' +rescue LoadError + raise "You don't have the 'fog' gem installed" +end + +module CarrierWave + module Storage + + ## + # Stores things using the "fog" gem. + # + # fog supports storing files with AWS, Google, Local and Rackspace + # + # You need to setup some options to configure your usage: + # + # [:fog_credentials] credentials for service + # [:fog_directory] specifies name of directory to store data in, assumed to already exist + # + # [:fog_attributes] (optional) additional attributes to set on files + # [:fog_host] (optional) non-default host to serve files from + # [:fog_public] (optional) public readability, defaults to true + # [:fog_authenticated_url_expiration] (optional) time (in seconds) that authenticated urls + # will be valid, when fog_public is false and provider is AWS or Google, defaults to 600 + # + # + # AWS credentials contain the following keys: + # + # [:aws_access_key_id] + # [:aws_secret_access_key] + # [:region] (optional) defaults to 'us-east-1' + # :region should be one of ['eu-west-1', 'us-east-1', 'ap-southeast-1', 'us-west-1', 'ap-northeast-1'] + # + # + # Google credentials contain the following keys: + # [:google_storage_access_key_id] + # [:google_storage_secrete_access_key] + # + # + # Local credentials contain the following keys: + # + # [:local_root] local path to files + # + # + # Rackspace credentials contain the following keys: + # + # [:rackspace_username] + # [:rackspace_api_key] + # + # + # A full example with AWS credentials: + # CarrierWave.configure do |config| + # config.fog_credentials = { + # :aws_access_key_id => 'xxxxxx', + # :aws_secret_access_key => 'yyyyyy', + # :provider => 'AWS' + # } + # config.fog_directory = 'directoryname' + # config.fog_public = true + # end + # + class Fog < Abstract + class << self + def connection_cache + @connection_cache ||= {} + end + end + + ## + # Store a file + # + # === Parameters + # + # [file (CarrierWave::SanitizedFile)] the file to store + # + # === Returns + # + # [CarrierWave::Storage::Fog::File] the stored file + # + def store!(file) + f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path) + f.store(file) + f + end + + ## + # Retrieve a file + # + # === Parameters + # + # [identifier (String)] unique identifier for file + # + # === Returns + # + # [CarrierWave::Storage::Fog::File] the stored file + # + def retrieve!(identifier) + CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path(identifier)) + end + + def connection + @connection ||= begin + credentials = uploader.fog_credentials + self.class.connection_cache[credentials] ||= ::Fog::Storage.new(credentials) + end + end + + class File + + ## + # Current local path to file + # + # === Returns + # + # [String] a path to file + # + attr_reader :path + + ## + # Return all attributes from file + # + # === Returns + # + # [Hash] attributes from file + # + def attributes + file.attributes + end + + ## + # Return a temporary authenticated url to a private file, if available + # Only supported for AWS and Google providers + # + # === Returns + # + # [String] temporary authenticated url + # or + # [NilClass] no authenticated url available + # + def authenticated_url(options = {}) + if ['AWS', 'Google'].include?(@uploader.fog_credentials[:provider]) + # avoid a get by using local references + local_directory = connection.directories.new(:key => @uploader.fog_directory) + local_file = local_directory.files.new(:key => path) + if @uploader.fog_credentials[:provider] == "AWS" + local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration, options) + else + local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration) + end + else + nil + end + end + + ## + # Lookup value for file content-type header + # + # === Returns + # + # [String] value of content-type + # + def content_type + @content_type || file.content_type + end + + ## + # Set non-default content-type header (default is file.content_type) + # + # === Returns + # + # [String] returns new content type value + # + def content_type=(new_content_type) + @content_type = new_content_type + end + + ## + # Remove the file from service + # + # === Returns + # + # [Boolean] true for success or raises error + # + def delete + # avoid a get by just using local reference + directory.files.new(:key => path).destroy + end + + ## + # deprecated: All attributes from file (includes headers) + # + # === Returns + # + # [Hash] attributes from file + # + def headers + location = caller.first + warning = "[yellow][WARN] headers is deprecated, use attributes instead[/]" + warning << " [light_black](#{location})[/]" + Formatador.display_line(warning) + attributes + end + + def initialize(uploader, base, path) + @uploader, @base, @path = uploader, base, path + end + + ## + # Read content of file from service + # + # === Returns + # + # [String] contents of file + def read + file.body + end + + ## + # Return size of file body + # + # === Returns + # + # [Integer] size of file body + # + def size + file.content_length + end + + ## + # Check if the file exists on the remote service + # + # === Returns + # + # [Boolean] true if file exists or false + def exists? + !!directory.files.head(path) + end + + ## + # Write file to service + # + # === Returns + # + # [Boolean] true on success or raises error + def store(new_file) + fog_file = new_file.to_file + @content_type ||= new_file.content_type + @file = directory.files.create({ + :body => fog_file ? fog_file : new_file.read, + :content_type => @content_type, + :key => path, + :public => @uploader.fog_public + }.merge(@uploader.fog_attributes)) + fog_file.close if fog_file && !fog_file.closed? + true + end + + ## + # Return a url to a public file, if available + # + # === Returns + # + # [String] public url + # or + # [NilClass] no public url available + # + def public_url + if host = @uploader.fog_host + if host.respond_to? :call + "#{host.call(self)}/#{path}" + else + "#{host}/#{path}" + end + else + # AWS/Google optimized for speed over correctness + case @uploader.fog_credentials[:provider] + when 'AWS' + # if directory is a valid subdomain, use that style for access + if @uploader.fog_directory.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\d{1,3}){3}$))(?:[a-z0-9]|(?![\-])|\-(?![\.])){1,61}[a-z0-9]$/ + "https://#{@uploader.fog_directory}.s3.amazonaws.com/#{path}" + else + # directory is not a valid subdomain, so use path style for access + "https://s3.amazonaws.com/#{@uploader.fog_directory}/#{path}" + end + when 'Google' + "https://commondatastorage.googleapis.com/#{@uploader.fog_directory}/#{path}" + else + # avoid a get by just using local reference + directory.files.new(:key => path).public_url + end + end + end + + ## + # Return url to file, if avaliable + # + # === Returns + # + # [String] url + # or + # [NilClass] no url available + # + def url(options = {}) + if !@uploader.fog_public + authenticated_url(options) + else + public_url + end + end + + private + + ## + # connection to service + # + # === Returns + # + # [Fog::#{provider}::Storage] connection to service + # + def connection + @base.connection + end + + ## + # local reference to directory containing file + # + # === Returns + # + # [Fog::#{provider}::Directory] containing directory + # + def directory + @directory ||= begin + connection.directories.new( + :key => @uploader.fog_directory, + :public => @uploader.fog_public + ) + end + end + + ## + # lookup file + # + # === Returns + # + # [Fog::#{provider}::File] file data from remote service + # + def file + @file ||= directory.files.head(path) + end + + end + + end # Fog + + end # Storage +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/test/matchers.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/test/matchers.rb new file mode 100644 index 000000000000..66183fe0ab38 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/test/matchers.rb @@ -0,0 +1,241 @@ +# encoding: utf-8 + +module CarrierWave + module Test + + ## + # These are some matchers that can be used in RSpec specs, to simplify the testing + # of uploaders. + # + module Matchers + + class BeIdenticalTo # :nodoc: + def initialize(expected) + @expected = expected + end + + def matches?(actual) + @actual = actual + FileUtils.identical?(@actual, @expected) + end + + def failure_message + "expected #{@actual.inspect} to be identical to #{@expected.inspect}" + end + + def negative_failure_message + "expected #{@actual.inspect} to not be identical to #{@expected.inspect}" + end + + def description + "be identical to #{@expected.inspect}" + end + end + + def be_identical_to(expected) + BeIdenticalTo.new(expected) + end + + class HavePermissions # :nodoc: + def initialize(expected) + @expected = expected + end + + def matches?(actual) + @actual = actual + # Satisfy expectation here. Return false or raise an error if it's not met. + (File.stat(@actual.path).mode & 0777) == @expected + end + + def failure_message + "expected #{@actual.current_path.inspect} to have permissions #{@expected.to_s(8)}, but they were #{(File.stat(@actual.path).mode & 0777).to_s(8)}" + end + + def negative_failure_message + "expected #{@actual.current_path.inspect} not to have permissions #{@expected.to_s(8)}, but it did" + end + + def description + "have permissions #{@expected.to_s(8)}" + end + end + + def have_permissions(expected) + HavePermissions.new(expected) + end + + class BeNoLargerThan # :nodoc: + def initialize(width, height) + @width, @height = width, height + end + + def matches?(actual) + @actual = actual + # Satisfy expectation here. Return false or raise an error if it's not met. + image = ImageLoader.load_image(@actual.current_path) + @actual_width = image.width + @actual_height = image.height + @actual_width <= @width && @actual_height <= @height + end + + def failure_message + "expected #{@actual.current_path.inspect} to be no larger than #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}." + end + + def negative_failure_message + "expected #{@actual.current_path.inspect} to be larger than #{@width} by #{@height}, but it wasn't." + end + + def description + "be no larger than #{@width} by #{@height}" + end + end + + def be_no_larger_than(width, height) + BeNoLargerThan.new(width, height) + end + + class HaveDimensions # :nodoc: + def initialize(width, height) + @width, @height = width, height + end + + def matches?(actual) + @actual = actual + # Satisfy expectation here. Return false or raise an error if it's not met. + image = ImageLoader.load_image(@actual.current_path) + @actual_width = image.width + @actual_height = image.height + @actual_width == @width && @actual_height == @height + end + + def failure_message + "expected #{@actual.current_path.inspect} to have an exact size of #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}." + end + + def negative_failure_message + "expected #{@actual.current_path.inspect} not to have an exact size of #{@width} by #{@height}, but it did." + end + + def description + "have an exact size of #{@width} by #{@height}" + end + end + + def have_dimensions(width, height) + HaveDimensions.new(width, height) + end + + class BeNoWiderThan # :nodoc: + def initialize(width) + @width = width + end + + def matches?(actual) + @actual = actual + # Satisfy expectation here. Return false or raise an error if it's not met. + image = ImageLoader.load_image(@actual.current_path) + @actual_width = image.width + @actual_width <= @width + end + + def failure_message + "expected #{@actual.current_path.inspect} to be no wider than #{@width}, but it was #{@actual_width}." + end + + def negative_failure_message + "expected #{@actual.current_path.inspect} not to be wider than #{@width}, but it is." + end + + def description + "have a width less than or equal to #{@width}" + end + end + + def be_no_wider_than(width) + BeNoWiderThan.new(width) + end + + class BeNoTallerThan # :nodoc: + def initialize(height) + @height = height + end + + def matches?(actual) + @actual = actual + # Satisfy expectation here. Return false or raise an error if it's not met. + image = ImageLoader.load_image(@actual.current_path) + @actual_height = image.height + @actual_height <= @height + end + + def failure_message + "expected #{@actual.current_path.inspect} to be no taller than #{@height}, but it was #{@actual_height}." + end + + def negative_failure_message + "expected #{@actual.current_path.inspect} not to be taller than #{@height}, but it is." + end + + def description + "have a height less than or equal to #{@height}" + end + end + + def be_no_taller_than(height) + BeNoTallerThan.new(height) + end + + class ImageLoader # :nodoc: + def self.load_image(filename) + if defined? ::MiniMagick + MiniMagickWrapper.new(filename) + else + unless defined? ::Magick + begin + require 'rmagick' + rescue LoadError + require 'RMagick' + rescue LoadError + puts "WARNING: Failed to require rmagick, image processing may fail!" + end + end + MagickWrapper.new(filename) + end + end + end + + class MagickWrapper # :nodoc: + attr_reader :image + def width + image.columns + end + + def height + image.rows + end + + def initialize(filename) + @image = ::Magick::Image.read(filename).first + end + end + + class MiniMagickWrapper # :nodoc: + attr_reader :image + def width + image[:width] + end + + def height + image[:height] + end + + def initialize(filename) + @image = ::MiniMagick::Image.open(filename) + end + end + + end # Matchers + end # Test +end # CarrierWave + diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader.rb new file mode 100644 index 000000000000..eaa1da96c197 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader.rb @@ -0,0 +1,45 @@ +# encoding: utf-8 + +module CarrierWave + + ## + # See CarrierWave::Uploader::Base + # + module Uploader + + ## + # An uploader is a class that allows you to easily handle the caching and storage of + # uploaded files. Please refer to the README for configuration options. + # + # Once you have an uploader you can use it in isolation: + # + # my_uploader = MyUploader.new + # my_uploader.cache!(File.open(path_to_file)) + # my_uploader.retrieve_from_store!('monkey.png') + # + # Alternatively, you can mount it on an ORM or other persistence layer, with + # +CarrierWave::Mount#mount_uploader+. There are extensions for activerecord and datamapper + # these are *very* simple (they are only a dozen lines of code), so adding your own should + # be trivial. + # + class Base + attr_reader :file + + include CarrierWave::Uploader::Callbacks + include CarrierWave::Uploader::Proxy + include CarrierWave::Uploader::Url + include CarrierWave::Uploader::Mountable + include CarrierWave::Uploader::Cache + include CarrierWave::Uploader::Store + include CarrierWave::Uploader::Download + include CarrierWave::Uploader::Remove + include CarrierWave::Uploader::ExtensionWhitelist + include CarrierWave::Uploader::Processing + include CarrierWave::Uploader::Versions + include CarrierWave::Uploader::DefaultUrl + include CarrierWave::Uploader::Configuration + include CarrierWave::Uploader::Serialization + end # Base + + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/cache.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/cache.rb new file mode 100644 index 000000000000..1aa8a723a3b1 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/cache.rb @@ -0,0 +1,169 @@ +# encoding: utf-8 + +module CarrierWave + + class FormNotMultipart < UploadError + def message + "You tried to assign a String or a Pathname to an uploader, for security reasons, this is not allowed.\n\n If this is a file upload, please check that your upload form is multipart encoded." + end + end + + ## + # Generates a unique cache id for use in the caching system + # + # === Returns + # + # [String] a cache id in the format YYYYMMDD-HHMM-PID-RND + # + def self.generate_cache_id + Time.now.strftime('%Y%m%d-%H%M') + '-' + Process.pid.to_s + '-' + ("%04d" % rand(9999)) + end + + module Uploader + module Cache + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + include CarrierWave::Uploader::Configuration + + module ClassMethods + + ## + # Removes cached files which are older than one day. You could call this method + # from a rake task to clean out old cached files. + # + # You can call this method directly on the module like this: + # + # CarrierWave.clean_cached_files! + # + # === Note + # + # This only works as long as you haven't done anything funky with your cache_dir. + # It's recommended that you keep cache files in one place only. + # + def clean_cached_files!(seconds=60*60*24) + Dir.glob(File.expand_path(File.join(cache_dir, '*'), CarrierWave.root)).each do |dir| + time = dir.scan(/(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})/).first.map { |t| t.to_i } + time = Time.utc(*time) + if time < (Time.now.utc - seconds) + FileUtils.rm_rf(dir) + end + end + end + end + + ## + # Returns true if the uploader has been cached + # + # === Returns + # + # [Bool] whether the current file is cached + # + def cached? + @cache_id + end + + ## + # Caches the remotely stored file + # + # This is useful when about to process images. Most processing solutions + # require the file to be stored on the local filesystem. + # + def cache_stored_file! + sanitized = SanitizedFile.new :tempfile => StringIO.new(file.read), + :filename => File.basename(path), :content_type => file.content_type + + cache! sanitized + end + + ## + # Returns a String which uniquely identifies the currently cached file for later retrieval + # + # === Returns + # + # [String] a cache name, in the format YYYYMMDD-HHMM-PID-RND/filename.txt + # + def cache_name + File.join(cache_id, full_original_filename) if cache_id and original_filename + end + + ## + # Caches the given file. Calls process! to trigger any process callbacks. + # + # By default, cache!() uses copy_to(), which operates by copying the file + # to the cache, then deleting the original file. If move_to_cache() is + # overriden to return true, then cache!() uses move_to(), which simply + # moves the file to the cache. Useful for large files. + # + # === Parameters + # + # [new_file (File, IOString, Tempfile)] any kind of file object + # + # === Raises + # + # [CarrierWave::FormNotMultipart] if the assigned parameter is a string + # + def cache!(new_file) + new_file = CarrierWave::SanitizedFile.new(new_file) + + unless new_file.empty? + raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form + + with_callbacks(:cache, new_file) do + self.cache_id = CarrierWave.generate_cache_id unless cache_id + + @filename = new_file.filename + self.original_filename = new_file.filename + + if move_to_cache + @file = new_file.move_to(cache_path, permissions) + else + @file = new_file.copy_to(cache_path, permissions) + end + end + end + end + + ## + # Retrieves the file with the given cache_name from the cache. + # + # === Parameters + # + # [cache_name (String)] uniquely identifies a cache file + # + # === Raises + # + # [CarrierWave::InvalidParameter] if the cache_name is incorrectly formatted. + # + def retrieve_from_cache!(cache_name) + with_callbacks(:retrieve_from_cache, cache_name) do + self.cache_id, self.original_filename = cache_name.to_s.split('/', 2) + @filename = original_filename + @file = CarrierWave::SanitizedFile.new(cache_path) + end + end + + private + + def cache_path + File.expand_path(File.join(cache_dir, cache_name), root) + end + + attr_reader :cache_id, :original_filename + + # We can override the full_original_filename method in other modules + alias_method :full_original_filename, :original_filename + + def cache_id=(cache_id) + raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}\z/ + @cache_id = cache_id + end + + def original_filename=(filename) + raise CarrierWave::InvalidParameter, "invalid filename" if filename =~ CarrierWave::SanitizedFile.sanitize_regexp + @original_filename = filename + end + + end # Cache + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/callbacks.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/callbacks.rb new file mode 100644 index 000000000000..48b5c1b9fd54 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/callbacks.rb @@ -0,0 +1,35 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Callbacks + extend ActiveSupport::Concern + + included do + class_attribute :_before_callbacks, :_after_callbacks, + :instance_writer => false + self._before_callbacks = Hash.new [] + self._after_callbacks = Hash.new [] + end + + def with_callbacks(kind, *args) + self.class._before_callbacks[kind].each { |c| send c, *args } + yield + self.class._after_callbacks[kind].each { |c| send c, *args } + end + + module ClassMethods + def before(kind, callback) + self._before_callbacks = self._before_callbacks. + merge kind => _before_callbacks[kind] + [callback] + end + + def after(kind, callback) + self._after_callbacks = self._after_callbacks. + merge kind => _after_callbacks[kind] + [callback] + end + end # ClassMethods + + end # Callbacks + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/configuration.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/configuration.rb new file mode 100644 index 000000000000..98763f7f2ad0 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/configuration.rb @@ -0,0 +1,136 @@ +module CarrierWave + + module Uploader + module Configuration + extend ActiveSupport::Concern + + included do + class_attribute :_storage, :instance_writer => false + + add_config :root + add_config :base_path + add_config :permissions + add_config :storage_engines + add_config :store_dir + add_config :cache_dir + add_config :enable_processing + add_config :ensure_multipart_form + add_config :delete_tmp_file_after_storage + add_config :move_to_cache + add_config :move_to_store + add_config :remove_previously_stored_files_after_update + + # fog + add_config :fog_attributes + add_config :fog_credentials + add_config :fog_directory + add_config :fog_host + add_config :fog_public + add_config :fog_authenticated_url_expiration + + # Mounting + add_config :ignore_integrity_errors + add_config :ignore_processing_errors + add_config :validate_integrity + add_config :validate_processing + add_config :mount_on + + # set default values + reset_config + end + + module ClassMethods + + ## + # Sets the storage engine to be used when storing files with this uploader. + # Can be any class that implements a #store!(CarrierWave::SanitizedFile) and a #retrieve! + # method. See lib/carrierwave/storage/file.rb for an example. Storage engines should + # be added to CarrierWave::Uploader::Base.storage_engines so they can be referred + # to by a symbol, which should be more convenient + # + # If no argument is given, it will simply return the currently used storage engine. + # + # === Parameters + # + # [storage (Symbol, Class)] The storage engine to use for this uploader + # + # === Returns + # + # [Class] the storage engine to be used with this uploader + # + # === Examples + # + # storage :file + # storage CarrierWave::Storage::File + # storage MyCustomStorageEngine + # + def storage(storage = nil) + if storage + self._storage = storage.is_a?(Symbol) ? eval(storage_engines[storage]) : storage + end + _storage + end + alias_method :storage=, :storage + + def add_config(name) + class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def self.#{name}(value=nil) + @#{name} = value if value + return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name}) + name = superclass.#{name} + return nil if name.nil? && !instance_variable_defined?("@#{name}") + @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name + end + + def self.#{name}=(value) + @#{name} = value + end + + def #{name} + value = self.class.#{name} + value.instance_of?(Proc) ? value.call : value + end + RUBY + end + + def configure + yield self + end + + ## + # sets configuration back to default + # + def reset_config + configure do |config| + config.permissions = 0644 + config.storage_engines = { + :file => "CarrierWave::Storage::File", + :fog => "CarrierWave::Storage::Fog" + } + config.storage = :file + config.fog_attributes = {} + config.fog_credentials = {} + config.fog_public = true + config.fog_authenticated_url_expiration = 600 + config.store_dir = 'uploads' + config.cache_dir = 'uploads/tmp' + config.delete_tmp_file_after_storage = true + config.move_to_cache = false + config.move_to_store = false + config.remove_previously_stored_files_after_update = true + config.ignore_integrity_errors = true + config.ignore_processing_errors = true + config.validate_integrity = true + config.validate_processing = true + config.root = lambda { CarrierWave.root } + config.base_path = CarrierWave.base_path + config.enable_processing = true + config.ensure_multipart_form = true + end + end + end + + end + end +end + diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/default_url.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/default_url.rb new file mode 100644 index 000000000000..2c2592d1fb6c --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/default_url.rb @@ -0,0 +1,19 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module DefaultUrl + + def url(*args) + super || default_url + end + + ## + # Override this method in your uploader to provide a default url + # in case no file has been cached/stored yet. + # + def default_url; end + + end # DefaultPath + end # Uploader +end # CarrierWave \ No newline at end of file diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/download.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/download.rb new file mode 100644 index 000000000000..35beebc6860d --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/download.rb @@ -0,0 +1,75 @@ +# encoding: utf-8 + +require 'open-uri' + +module CarrierWave + module Uploader + module Download + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + include CarrierWave::Uploader::Configuration + include CarrierWave::Uploader::Cache + + class RemoteFile + def initialize(uri) + @uri = uri + end + + def original_filename + File.basename(file.base_uri.path) + end + + def respond_to?(*args) + super or file.respond_to?(*args) + end + + def http? + @uri.scheme =~ /^https?$/ + end + + private + + def file + if @file.blank? + @file = Kernel.open(@uri.to_s) + @file = @file.is_a?(String) ? StringIO.new(@file) : @file + end + @file + end + + def method_missing(*args, &block) + file.send(*args, &block) + end + end + + ## + # Caches the file by downloading it from the given URL. + # + # === Parameters + # + # [url (String)] The URL where the remote file is stored + # + def download!(uri) + unless uri.blank? + processed_uri = process_uri(uri) + file = RemoteFile.new(processed_uri) + raise CarrierWave::DownloadError, "trying to download a file which is not served over HTTP" unless file.http? + cache!(file) + end + end + + ## + # Processes the given URL by parsing and escaping it. Public to allow overriding. + # + # === Parameters + # + # [url (String)] The URL where the remote file is stored + # + def process_uri(uri) + URI.parse(URI.escape(URI.unescape(uri)).gsub("[", "%5B").gsub("]", "%5D").gsub("+", "%2B")) + end + + end # Download + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/extension_whitelist.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/extension_whitelist.rb new file mode 100644 index 000000000000..1d316071f709 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/extension_whitelist.rb @@ -0,0 +1,49 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module ExtensionWhitelist + extend ActiveSupport::Concern + + included do + before :cache, :check_whitelist! + end + + ## + # Override this method in your uploader to provide a white list of extensions which + # are allowed to be uploaded. Compares the file's extension case insensitive. + # Furthermore, not only strings but Regexp are allowed as well. + # + # When using a Regexp in the white list, `\A` and `\z` are automatically added to + # the Regexp expression, also case insensitive. + # + # === Returns + # + # [NilClass, Array[String,Regexp]] a white list of extensions which are allowed to be uploaded + # + # === Examples + # + # def extension_white_list + # %w(jpg jpeg gif png) + # end + # + # Basically the same, but using a Regexp: + # + # def extension_white_list + # [/jpe?g/, 'gif', 'png'] + # end + # + def extension_white_list; end + + private + + def check_whitelist!(new_file) + extension = new_file.extension.to_s + if extension_white_list and not extension_white_list.detect { |item| extension =~ /\A#{item}\z/i } + raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.extension_white_list_error", :extension => new_file.extension.inspect, :allowed_types => extension_white_list.inspect) + end + end + + end # ExtensionWhitelist + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/mountable.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/mountable.rb new file mode 100644 index 000000000000..54dfe1f75e64 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/mountable.rb @@ -0,0 +1,39 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Mountable + + attr_reader :model, :mounted_as + + ## + # If a model is given as the first parameter, it will be stored in the uploader, and + # available throught +#model+. Likewise, mounted_as stores the name of the column + # where this instance of the uploader is mounted. These values can then be used inside + # your uploader. + # + # If you do not wish to mount your uploaders with the ORM extensions in -more then you + # can override this method inside your uploader. Just be sure to call +super+ + # + # === Parameters + # + # [model (Object)] Any kind of model object + # [mounted_as (Symbol)] The name of the column where this uploader is mounted + # + # === Examples + # + # class MyUploader < CarrierWave::Uploader::Base + # + # def store_dir + # File.join('public', 'files', mounted_as, model.permalink) + # end + # end + # + def initialize(model=nil, mounted_as=nil) + @model = model + @mounted_as = mounted_as + end + + end # Mountable + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/processing.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/processing.rb new file mode 100644 index 000000000000..d3617f4d621c --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/processing.rb @@ -0,0 +1,92 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Processing + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + + included do + class_attribute :processors, :instance_writer => false + self.processors = [] + + after :cache, :process! + end + + module ClassMethods + + ## + # Adds a processor callback which applies operations as a file is uploaded. + # The argument may be the name of any method of the uploader, expressed as a symbol, + # or a list of such methods, or a hash where the key is a method and the value is + # an array of arguments to call the method with + # + # === Parameters + # + # args (*Symbol, Hash{Symbol => Array[]}) + # + # === Examples + # + # class MyUploader < CarrierWave::Uploader::Base + # + # process :sepiatone, :vignette + # process :scale => [200, 200] + # process :scale => [200, 200], :if => :image? + # process :sepiatone, :if => :image? + # + # def sepiatone + # ... + # end + # + # def vignette + # ... + # end + # + # def scale(height, width) + # ... + # end + # + # def image? + # ... + # end + # + # end + # + def process(*args) + if !args.first.is_a?(Hash) && args.last.is_a?(Hash) + conditions = args.pop + args.map!{ |arg| {arg => []}.merge(conditions) } + end + + args.each do |arg| + if arg.is_a?(Hash) + condition = arg.delete(:if) + arg.each do |method, args| + self.processors += [[method, args, condition]] + end + else + self.processors += [[arg, [], nil]] + end + end + end + + end # ClassMethods + + ## + # Apply all process callbacks added through CarrierWave.process + # + def process!(new_file=nil) + if enable_processing + self.class.processors.each do |method, args, condition| + if(condition) + next if !(condition.respond_to?(:call) ? condition.call(self, :args => args, :method => method, :file => new_file) : self.send(condition, new_file)) + end + self.send(method, *args) + end + end + end + + end # Processing + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/proxy.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/proxy.rb new file mode 100644 index 000000000000..ee8e59b706ab --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/proxy.rb @@ -0,0 +1,77 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Proxy + + ## + # === Returns + # + # [Boolean] Whether the uploaded file is blank + # + def blank? + file.blank? + end + + ## + # === Returns + # + # [String] the path where the file is currently located. + # + def current_path + file.path if file.respond_to?(:path) + end + + alias_method :path, :current_path + + ## + # Returns a string that uniquely identifies the last stored file + # + # === Returns + # + # [String] uniquely identifies a file + # + def identifier + storage.identifier if storage.respond_to?(:identifier) + end + + ## + # Read the contents of the file + # + # === Returns + # + # [String] contents of the file + # + def read + file.read if file.respond_to?(:read) + end + + ## + # Fetches the size of the currently stored/cached file + # + # === Returns + # + # [Integer] size of the file + # + def size + file.respond_to?(:size) ? file.size : 0 + end + + ## + # Return the size of the file when asked for its length + # + # === Returns + # + # [Integer] size of the file + # + # === Note + # + # This was added because of the way Rails handles length/size validations in 3.0.6 and above. + # + def length + size + end + + end # Proxy + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/remove.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/remove.rb new file mode 100644 index 000000000000..54add98a8475 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/remove.rb @@ -0,0 +1,23 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Remove + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + + ## + # Removes the file and reset it + # + def remove! + with_callbacks(:remove) do + @file.delete if @file + @file = nil + @cache_id = nil + end + end + + end # Remove + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/serialization.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/serialization.rb new file mode 100644 index 000000000000..f8248e01c3fb --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/serialization.rb @@ -0,0 +1,30 @@ +# encoding: utf-8 + +require "active_support/json" +require "active_support/core_ext/hash" + +module CarrierWave + module Uploader + module Serialization + extend ActiveSupport::Concern + + def serializable_hash + {"url" => url}.merge Hash[versions.map { |name, version| [name, { "url" => version.url }] }] + end + + def as_json(options=nil) + Hash[mounted_as || "uploader", serializable_hash] + end + + def to_json + ActiveSupport::JSON.encode(as_json) + end + + def to_xml(options={}) + merged_options = options.merge(:root => mounted_as || "uploader", :type => 'uploader') + serializable_hash.to_xml(merged_options) + end + + end + end +end diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/store.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/store.rb new file mode 100644 index 000000000000..19ccc290af71 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/store.rb @@ -0,0 +1,111 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Store + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + include CarrierWave::Uploader::Configuration + include CarrierWave::Uploader::Cache + + ## + # Override this in your Uploader to change the filename. + # + # Be careful using record ids as filenames. If the filename is stored in the database + # the record id will be nil when the filename is set. Don't use record ids unless you + # understand this limitation. + # + # Do not use the version_name in the filename, as it will prevent versions from being + # loaded correctly. + # + # === Returns + # + # [String] a filename + # + def filename + @filename + end + + ## + # Calculates the path where the file should be stored. If +for_file+ is given, it will be + # used as the filename, otherwise +CarrierWave::Uploader#filename+ is assumed. + # + # === Parameters + # + # [for_file (String)] name of the file + # + # === Returns + # + # [String] the store path + # + def store_path(for_file=filename) + File.join([store_dir, full_filename(for_file)].compact) + end + + ## + # Stores the file by passing it to this Uploader's storage engine. + # + # If new_file is omitted, a previously cached file will be stored. + # + # === Parameters + # + # [new_file (File, IOString, Tempfile)] any kind of file object + # + def store!(new_file=nil) + cache!(new_file) if new_file && ((@cache_id != parent_cache_id) || @cache_id.nil?) + if @file and @cache_id + with_callbacks(:store, new_file) do + new_file = storage.store!(@file) + @file.delete if (delete_tmp_file_after_storage && ! move_to_store) + delete_cache_id + @file = new_file + @cache_id = nil + end + end + end + + ## + # Deletes a cache id (tmp dir in cache) + # + def delete_cache_id + if @cache_id + path = File.expand_path(File.join(cache_dir, @cache_id), CarrierWave.root) + begin + Dir.rmdir(path) + rescue Errno::ENOENT + # Ignore: path does not exist + rescue Errno::ENOTDIR + # Ignore: path is not a dir + rescue Errno::ENOTEMPTY, Errno::EEXIST + # Ignore: dir is not empty + end + end + end + + ## + # Retrieves the file from the storage. + # + # === Parameters + # + # [identifier (String)] uniquely identifies the file to retrieve + # + def retrieve_from_store!(identifier) + with_callbacks(:retrieve_from_store, identifier) do + @file = storage.retrieve!(identifier) + end + end + + private + + def full_filename(for_file) + for_file + end + + def storage + @storage ||= self.class.storage.new(self) + end + + end # Store + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/url.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/url.rb new file mode 100644 index 000000000000..c64f04043dec --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/url.rb @@ -0,0 +1,32 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Url + extend ActiveSupport::Concern + include CarrierWave::Uploader::Configuration + + ## + # === Parameters + # + # [Hash] optional, the query params (only AWS) + # + # === Returns + # + # [String] the location where this file is accessible via a url + # + def url(options = {}) + if file.respond_to?(:url) and not file.url.blank? + file.method(:url).arity == 0 ? file.url : file.url(options) + elsif current_path + (base_path || "") + File.expand_path(current_path).gsub(File.expand_path(root), '') + end + end + + def to_s + url || '' + end + + end # Url + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/versions.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/versions.rb new file mode 100644 index 000000000000..b2e432282fd8 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/uploader/versions.rb @@ -0,0 +1,254 @@ +# encoding: utf-8 + +module CarrierWave + module Uploader + module Versions + extend ActiveSupport::Concern + + include CarrierWave::Uploader::Callbacks + + included do + class_attribute :versions, :version_names, :instance_reader => false, :instance_writer => false + + self.versions = {} + self.version_names = [] + + attr_accessor :parent_cache_id + + after :cache, :assign_parent_cache_id + after :cache, :cache_versions! + after :store, :store_versions! + after :remove, :remove_versions! + after :retrieve_from_cache, :retrieve_versions_from_cache! + after :retrieve_from_store, :retrieve_versions_from_store! + end + + module ClassMethods + + ## + # Adds a new version to this uploader + # + # === Parameters + # + # [name (#to_sym)] name of the version + # [options (Hash)] optional options hash + # [&block (Proc)] a block to eval on this version of the uploader + # + # === Examples + # + # class MyUploader < CarrierWave::Uploader::Base + # + # version :thumb do + # process :scale => [200, 200] + # end + # + # version :preview, :if => :image? do + # process :scale => [200, 200] + # end + # + # end + # + def version(name, options = {}, &block) + name = name.to_sym + unless versions[name] + uploader = Class.new(self) + uploader.versions = {} + + # Define the enable_processing method for versions so they get the + # value from the parent class unless explicitly overwritten + uploader.class_eval <<-RUBY, __FILE__, __LINE__ + 1 + def self.enable_processing(value=nil) + self.enable_processing = value if value + if !@enable_processing.nil? + @enable_processing + else + superclass.enable_processing + end + end + RUBY + + # Add the current version hash to class attribute :versions + current_version = {} + current_version[name] = { + :uploader => uploader, + :options => options + } + self.versions = versions.merge(current_version) + + versions[name][:uploader].version_names += [name] + + class_eval <<-RUBY + def #{name} + versions[:#{name}] + end + RUBY + # as the processors get the output from the previous processors as their + # input we must not stack the processors here + versions[name][:uploader].processors = versions[name][:uploader].processors.dup + versions[name][:uploader].processors.clear + end + versions[name][:uploader].class_eval(&block) if block + versions[name] + end + + def recursively_apply_block_to_versions(&block) + versions.each do |name, version| + version[:uploader].class_eval(&block) + version[:uploader].recursively_apply_block_to_versions(&block) + end + end + end # ClassMethods + + ## + # Returns a hash mapping the name of each version of the uploader to an instance of it + # + # === Returns + # + # [Hash{Symbol => CarrierWave::Uploader}] a list of uploader instances + # + def versions + return @versions if @versions + @versions = {} + self.class.versions.each do |name, version| + @versions[name] = version[:uploader].new(model, mounted_as) + end + @versions + end + + ## + # === Returns + # + # [String] the name of this version of the uploader + # + def version_name + self.class.version_names.join('_').to_sym unless self.class.version_names.blank? + end + + ## + # When given a version name as a parameter, will return the url for that version + # This also works with nested versions. + # When given a query hash as a parameter, will return the url with signature that contains query params + # Query hash only works with AWS (S3 storage). + # + # === Example + # + # my_uploader.url # => /path/to/my/uploader.gif + # my_uploader.url(:thumb) # => /path/to/my/thumb_uploader.gif + # my_uploader.url(:thumb, :small) # => /path/to/my/thumb_small_uploader.gif + # my_uploader.url(:query => {"response-content-disposition" => "attachment"}) + # my_uploader.url(:version, :sub_version, :query => {"response-content-disposition" => "attachment"}) + # + # === Parameters + # + # [*args (Symbol)] any number of versions + # OR/AND + # [Hash] query params + # + # === Returns + # + # [String] the location where this file is accessible via a url + # + def url(*args) + if (version = args.first) && version.respond_to?(:to_sym) + raise ArgumentError, "Version #{version} doesn't exist!" if versions[version.to_sym].nil? + # recursively proxy to version + versions[version.to_sym].url(*args[1..-1]) + elsif args.first + super(args.first) + else + super + end + end + + ## + # Recreate versions and reprocess them. This can be used to recreate + # versions if their parameters somehow have changed. + # + def recreate_versions! + # Some files could possibly not be stored on the local disk. This + # doesn't play nicely with processing. Make sure that we're only + # processing a cached file + # + # The call to store! will trigger the necessary callbacks to both + # process this version and all sub-versions + cache_stored_file! if !cached? + + store! + end + + private + def assign_parent_cache_id(file) + active_versions.each do |name, uploader| + uploader.parent_cache_id = @cache_id + end + end + + def active_versions + versions.select do |name, uploader| + condition = self.class.versions[name][:options][:if] + if(condition) + if(condition.respond_to?(:call)) + condition.call(self, :version => name, :file => file) + else + send(condition, file) + end + else + true + end + end + end + + def full_filename(for_file) + [version_name, super(for_file)].compact.join('_') + end + + def full_original_filename + [version_name, super].compact.join('_') + end + + def cache_versions!(new_file) + # We might have processed the new_file argument after the callbacks were + # initialized, so get the actual file based off of the current state of + # our file + processed_parent = SanitizedFile.new :tempfile => self.file, + :filename => new_file.original_filename + + active_versions.each do |name, v| + next if v.cached? + + v.send(:cache_id=, cache_id) + # If option :from_version is present, create cache using cached file from + # version indicated + if self.class.versions[name][:options] && self.class.versions[name][:options][:from_version] + # Maybe the reference version has not been cached yet + unless versions[self.class.versions[name][:options][:from_version]].cached? + versions[self.class.versions[name][:options][:from_version]].cache!(processed_parent) + end + processed_version = SanitizedFile.new :tempfile => versions[self.class.versions[name][:options][:from_version]], + :filename => new_file.original_filename + v.cache!(processed_version) + else + v.cache!(processed_parent) + end + end + end + + def store_versions!(new_file) + active_versions.each { |name, v| v.store!(new_file) } + end + + def remove_versions! + versions.each { |name, v| v.remove! } + end + + def retrieve_versions_from_cache!(cache_name) + versions.each { |name, v| v.retrieve_from_cache!(cache_name) } + end + + def retrieve_versions_from_store!(identifier) + versions.each { |name, v| v.retrieve_from_store!(identifier) } + end + + end # Versions + end # Uploader +end # CarrierWave diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/validations/active_model.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/validations/active_model.rb new file mode 100644 index 000000000000..2de431e71c16 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/validations/active_model.rb @@ -0,0 +1,63 @@ +# encoding: utf-8 + +require 'active_model/validator' +require 'active_support/concern' + +module CarrierWave + + # == Active Model Presence Validator + module Validations + module ActiveModel + extend ActiveSupport::Concern + + class ProcessingValidator < ::ActiveModel::EachValidator + + def validate_each(record, attribute, value) + if e = record.send("#{attribute}_processing_error") + message = (e.message == e.class.to_s) ? :carrierwave_processing_error : e.message + record.errors.add(attribute, message) + end + end + end + + class IntegrityValidator < ::ActiveModel::EachValidator + + def validate_each(record, attribute, value) + if e = record.send("#{attribute}_integrity_error") + message = (e.message == e.class.to_s) ? :carrierwave_integrity_error : e.message + record.errors.add(attribute, message) + end + end + end + + module HelperMethods + + ## + # Makes the record invalid if the file couldn't be uploaded due to an integrity error + # + # Accepts the usual parameters for validations in Rails (:if, :unless, etc...) + # + def validates_integrity_of(*attr_names) + validates_with IntegrityValidator, _merge_attributes(attr_names) + end + + ## + # Makes the record invalid if the file couldn't be processed (assuming the process failed + # with a CarrierWave::ProcessingError) + # + # Accepts the usual parameters for validations in Rails (:if, :unless, etc...) + # + def validates_processing_of(*attr_names) + validates_with ProcessingValidator, _merge_attributes(attr_names) + end + end + + included do + extend HelperMethods + include HelperMethods + end + end + end +end + +I18n.load_path << File.join(File.dirname(__FILE__), "..", "locale", 'en.yml') diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/version.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/version.rb new file mode 100644 index 000000000000..62aa1b062adf --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/carrierwave/version.rb @@ -0,0 +1,3 @@ +module CarrierWave + VERSION = "0.6.2" +end diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/templates/uploader.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/templates/uploader.rb new file mode 100644 index 000000000000..ccb5792ba6ae --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/templates/uploader.rb @@ -0,0 +1,55 @@ +# encoding: utf-8 + +class <%= class_name %>Uploader < CarrierWave::Uploader::Base + + # Include RMagick or MiniMagick support: + # include CarrierWave::RMagick + # include CarrierWave::MiniMagick + + # Include the Sprockets helpers for Rails 3.1+ asset pipeline compatibility: + # include Sprockets::Helpers::RailsHelper + # include Sprockets::Helpers::IsolatedHelper + + # Choose what kind of storage to use for this uploader: + storage :file + # storage :fog + + # Override the directory where uploaded files will be stored. + # This is a sensible default for uploaders that are meant to be mounted: + def store_dir + "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}" + end + + # Provide a default URL as a default if there hasn't been a file uploaded: + # def default_url + # # For Rails 3.1+ asset pipeline compatibility: + # # asset_path("fallback/" + [version_name, "default.png"].compact.join('_')) + # + # "/images/fallback/" + [version_name, "default.png"].compact.join('_') + # end + + # Process files as they are uploaded: + # process :scale => [200, 300] + # + # def scale(width, height) + # # do something + # end + + # Create different versions of your uploaded files: + # version :thumb do + # process :scale => [50, 50] + # end + + # Add a white list of extensions which are allowed to be uploaded. + # For images you might use something like this: + # def extension_white_list + # %w(jpg jpeg gif png) + # end + + # Override the filename of the uploaded files: + # Avoid using model.id or version_name here, see uploader/store.rb for details. + # def filename + # "something.jpg" if original_filename + # end + +end diff --git a/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/uploader_generator.rb b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/uploader_generator.rb new file mode 100644 index 000000000000..e08c1762b519 --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/gems/carrierwave-0.6.2/lib/generators/uploader_generator.rb @@ -0,0 +1,7 @@ +class UploaderGenerator < Rails::Generators::NamedBase + source_root File.expand_path("../templates", __FILE__) + + def create_uploader_file + template "uploader.rb", "app/uploaders/#{file_name}_uploader.rb" + end +end \ No newline at end of file diff --git a/lib/gemcache/ruby/1.9.1/specifications/carrierwave-0.6.2.gemspec b/lib/gemcache/ruby/1.9.1/specifications/carrierwave-0.6.2.gemspec new file mode 100644 index 000000000000..1eedbcdc2f6b --- /dev/null +++ b/lib/gemcache/ruby/1.9.1/specifications/carrierwave-0.6.2.gemspec @@ -0,0 +1,65 @@ +# -*- encoding: utf-8 -*- + +Gem::Specification.new do |s| + s.name = "carrierwave" + s.version = "0.6.2" + + s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= + s.authors = ["Jonas Nicklas"] + s.date = "2012-04-12" + s.description = "Upload files in your Ruby applications, map them to a range of ORMs, store them on different backends." + s.email = ["jonas.nicklas@gmail.com"] + s.extra_rdoc_files = ["README.md"] + s.files = ["README.md"] + s.homepage = "https://github.com/jnicklas/carrierwave" + s.rdoc_options = ["--main"] + s.require_paths = ["lib"] + s.rubyforge_project = "carrierwave" + s.rubygems_version = "1.8.15" + s.summary = "Ruby file upload library" + + if s.respond_to? :specification_version then + s.specification_version = 3 + + if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then + s.add_runtime_dependency(%q, [">= 3.2.0"]) + s.add_runtime_dependency(%q, [">= 3.2.0"]) + s.add_development_dependency(%q, [">= 0"]) + s.add_development_dependency(%q, [">= 3.2.0"]) + s.add_development_dependency(%q, ["= 1.1.4"]) + s.add_development_dependency(%q, [">= 0"]) + s.add_development_dependency(%q, ["~> 2.0"]) + s.add_development_dependency(%q, [">= 0"]) + s.add_development_dependency(%q, [">= 0"]) + s.add_development_dependency(%q, [">= 1.3.1"]) + s.add_development_dependency(%q, [">= 0"]) + s.add_development_dependency(%q, [">= 0"]) + else + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, ["= 1.1.4"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, ["~> 2.0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 1.3.1"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 0"]) + end + else + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 3.2.0"]) + s.add_dependency(%q, ["= 1.1.4"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, ["~> 2.0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 1.3.1"]) + s.add_dependency(%q, [">= 0"]) + s.add_dependency(%q, [">= 0"]) + end +end