carrierwave-pressplane 0.5.8.3

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

data/lib/carrierwave/uploader/configuration.rb

@@ -0,0 +1,168 @@
+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 :s3_access_policy
+        add_config :s3_bucket
+        add_config :s3_access_key_id
+        add_config :s3_secret_access_key
+        add_config :s3_cnamed
+        add_config :s3_headers
+        add_config :s3_region
+        add_config :s3_use_ssl
+        add_config :s3_authentication_timeout
+        add_config :cloud_files_username
+        add_config :cloud_files_api_key
+        add_config :cloud_files_container
+        add_config :cloud_files_cdn_host
+        add_config :cloud_files_auth_url
+        add_config :cloud_files_snet
+        add_config :grid_fs_connection
+        add_config :grid_fs_database
+        add_config :grid_fs_host
+        add_config :grid_fs_port
+        add_config :grid_fs_username
+        add_config :grid_fs_password
+        add_config :grid_fs_access_url
+        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}
+              self.class.#{name}
+            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",
+              :s3 => "CarrierWave::Storage::S3",
+              :grid_fs => "CarrierWave::Storage::GridFS",
+              :right_s3 => "CarrierWave::Storage::RightS3",
+              :cloud_files => "CarrierWave::Storage::CloudFiles"
+            }
+            config.storage = :file
+            config.s3_headers = {}
+            config.s3_access_policy = :public_read
+            config.s3_region = 'us-east-1'
+            config.s3_authentication_timeout = 600
+            config.grid_fs_database = 'carrierwave'
+            config.grid_fs_host = 'localhost'
+            config.grid_fs_port = 27017
+            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 = CarrierWave.root
+            config.base_path = CarrierWave.base_path
+            config.enable_processing = true
+            config.ensure_multipart_form = true
+          end
+        end
+      end
+
+    end
+  end
+end
+

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

data/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)))
+      end
+
+    end # Download
+  end # Uploader
+end # CarrierWave

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

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

data/lib/carrierwave/uploader/processing.rb

@@ -0,0 +1,90 @@
+# 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|
+            next if condition && !self.send(condition, new_file)
+            self.send(method, *args)
+          end
+        end
+      end
+
+    end # Processing
+  end # Uploader
+end # CarrierWave