card 1.19.3 → 1.19.4

data/vendor/carrierwave/lib/carrierwave/uploader/mountable.rb

@@ -1,38 +0,0 @@
-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 through +#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/vendor/carrierwave/lib/carrierwave/uploader/processing.rb

@@ -1,88 +0,0 @@
-module CarrierWave
-  module Uploader
-    module Processing
-      extend ActiveSupport::Concern
-
-      include CarrierWave::Uploader::Callbacks
-
-      included do
-        class_attribute :processors, :instance_writer => false
-        self.processors = []
-
-        before :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)
-          new_processors = args.inject({}) do |hash, arg|
-            arg = { arg => [] } unless arg.is_a?(Hash)
-            hash.merge!(arg)
-          end
-
-          condition = new_processors.delete(:if)
-          new_processors.each do |processor, processor_args|
-            self.processors += [[processor, processor_args, condition]]
-          end
-        end
-
-      end # ClassMethods
-
-      ##
-      # Apply all process callbacks added through CarrierWave.process
-      #
-      def process!(new_file=nil)
-        return unless enable_processing
-
-        self.class.processors.each do |method, args, condition|
-          if(condition)
-            if condition.respond_to?(:call)
-              next unless condition.call(self, :args => args, :method => method, :file => new_file)
-            else
-              next unless self.send(condition, new_file)
-            end
-          end
-          self.send(method, *args)
-        end
-      end
-
-    end # Processing
-  end # Uploader
-end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/uploader/proxy.rb

@@ -1,86 +0,0 @@
-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.try(: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.try(:identifier)
-      end
-
-      ##
-      # Read the contents of the file
-      #
-      # === Returns
-      #
-      # [String] contents of the file
-      #
-      def read
-        file.try(:read)
-      end
-
-      ##
-      # Fetches the size of the currently stored/cached file
-      #
-      # === Returns
-      #
-      # [Integer] size of the file
-      #
-      def size
-        file.try(: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
-
-      ##
-      # Read the content type of the file
-      #
-      # === Returns
-      #
-      # [String] content type of the file
-      #
-      def content_type
-        file.try(:content_type)
-      end
-
-    end # Proxy
-  end # Uploader
-end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/uploader/remove.rb

@@ -1,21 +0,0 @@
-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

data/vendor/carrierwave/lib/carrierwave/uploader/serialization.rb

@@ -1,28 +0,0 @@
-require "json"
-require "active_support/core_ext/hash"
-
-module CarrierWave
-  module Uploader
-    module Serialization
-      extend ActiveSupport::Concern
-
-      def serializable_hash(options = nil)
-        {"url" => url}.merge Hash[versions.map { |name, version| [name, { "url" => version.url }] }]
-      end
-
-      def as_json(options=nil)
-        serializable_hash
-      end
-
-      def to_json(options=nil)
-        JSON.generate(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

data/vendor/carrierwave/lib/carrierwave/uploader/store.rb

@@ -1,93 +0,0 @@
-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 <optional>
-      #
-      # === 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 !cache_only and @file and @cache_id
-          with_callbacks(:store, new_file) do
-            new_file = storage.store!(@file)
-            if delete_tmp_file_after_storage
-              @file.delete unless move_to_store
-              cache_storage.delete_dir!(cache_path(nil))
-            end
-            @file = new_file
-            @cache_id = nil
-          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

data/vendor/carrierwave/lib/carrierwave/uploader/url.rb

@@ -1,41 +0,0 @@
-module CarrierWave
-  module Uploader
-    module Url
-      extend ActiveSupport::Concern
-      include CarrierWave::Uploader::Configuration
-      include CarrierWave::Utilities::Uri
-
-      ##
-      # === 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 file.respond_to?(:path)
-          path = encode_path(file.path.sub(File.expand_path(root), ''))
-
-          if host = asset_host
-            if host.respond_to? :call
-              "#{host.call(file)}#{path}"
-            else
-              "#{host}#{path}"
-            end
-          else
-            (base_path || "") + path
-          end
-        end
-      end
-
-      def to_s
-        url || ''
-      end
-
-    end # Url
-  end # Uploader
-end # CarrierWave

data/vendor/carrierwave/lib/carrierwave/uploader/versions.rb

@@ -1,295 +0,0 @@
-module CarrierWave
-  module Uploader
-    module Versions
-      extend ActiveSupport::Concern
-
-      include CarrierWave::Uploader::Callbacks
-
-      included do
-        class_attribute :versions, :version_names, :version_options, :instance_reader => false, :instance_writer => false
-
-        self.versions = {}
-        self.version_names = []
-
-        attr_accessor :parent_cache_id, :parent_version
-
-        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
-          build_version(name, options)
-
-          versions[name].class_eval(&block) if block
-          versions[name]
-        end
-
-        def recursively_apply_block_to_versions(&block)
-          versions.each do |name, version|
-            version.class_eval(&block)
-            version.recursively_apply_block_to_versions(&block)
-          end
-        end
-
-      private
-
-        def build_version(name, options)
-          if !versions.has_key?(name)
-            uploader = Class.new(self)
-            const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
-            uploader.version_names += [name]
-            uploader.versions = {}
-            uploader.processors = []
-            uploader.version_options = options
-
-            uploader.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              # Define the enable_processing method for versions so they get the
-              # value from the parent class unless explicitly overwritten
-              def self.enable_processing(value=nil)
-                self.enable_processing = value if value
-                if !@enable_processing.nil?
-                  @enable_processing
-                else
-                  superclass.enable_processing
-                end
-              end
-
-              # Regardless of what is set in the parent uploader, do not enforce the
-              # move_to_cache config option on versions because it moves the original
-              # file to the version's target file.
-              #
-              # If you want to enforce this setting on versions, override this method
-              # in each version:
-              #
-              # version :thumb do
-              #   def move_to_cache
-              #     true
-              #   end
-              # end
-              #
-              def move_to_cache
-                false
-              end
-            RUBY
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                versions[:#{name}]
-              end
-            RUBY
-          else
-            uploader = Class.new(versions[name])
-            const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
-            uploader.processors = []
-            uploader.version_options = uploader.version_options.merge(options)
-          end
-
-          # Add the current version hash to class attribute :versions
-          self.versions = versions.merge(name => uploader)
-        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.new(model, mounted_as)
-          @versions[name].parent_version = self
-        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
-
-      ##
-      #
-      # === Parameters
-      #
-      # [name (#to_sym)] name of the version
-      #
-      # === Returns
-      #
-      # [Boolean] True when the version exists according to its :if condition
-      #
-      def version_exists?(name)
-        name = name.to_sym
-
-        return false unless self.class.versions.has_key?(name)
-
-        condition = self.class.versions[name].version_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
-
-      ##
-      # 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!(*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
-        if versions.any?
-          file = sanitized_file if !cached?
-          store_versions!(file, versions)
-        else
-          cache! if !cached?
-          store!
-        end
-      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|
-          version_exists?(name)
-        end
-      end
-
-      def dependent_versions
-        active_versions.reject do |name, v|
-          v.class.version_options[:from_version]
-        end.to_a + sibling_versions.select do |name, v|
-          v.class.version_options[:from_version] == self.class.version_names.last
-        end.to_a
-      end
-
-      def sibling_versions
-        parent_version.try(:versions) || []
-      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)
-        dependent_versions.each do |name, v|
-          v.send(:cache_id=, @cache_id)
-          v.cache!(new_file)
-        end
-      end
-
-      def store_versions!(new_file, versions=nil)
-        if versions
-          active = Hash[active_versions]
-          versions.each { |v| active[v].try(:store!, new_file) } unless active.empty?
-        else
-          active_versions.each { |name, v| v.store!(new_file) }
-        end
-      end
-
-      def remove_versions!
-        versions.each { |name, v| v.remove! }
-      end
-
-      def retrieve_versions_from_cache!(cache_name)
-        active_versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
-      end
-
-      def retrieve_versions_from_store!(identifier)
-        active_versions.each { |name, v| v.retrieve_from_store!(identifier) }
-      end
-
-    end # Versions
-  end # Uploader
-end # CarrierWave