mini-smart-pkg 0.0.1

data/carrierwave-3.1.3/lib/carrierwave/uploader/processing.rb

@@ -0,0 +1,128 @@
+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. Also accepts an :if or :unless condition
+        #
+        # === 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 :scale => [200, 200], :unless => :disallowed_image_type?
+        #       process :sepiatone, :if => :image?
+        #
+        #       def sepiatone
+        #         ...
+        #       end
+        #
+        #       def vignette
+        #         ...
+        #       end
+        #
+        #       def scale(height, width)
+        #         ...
+        #       end
+        #
+        #       def image?
+        #         ...
+        #       end
+        #
+        #       def disallowed_image_type?
+        #         ...
+        #       end
+        #
+        #     end
+        #
+        def process(*args)
+          new_processors = args.inject({}) do |hash, arg|
+            arg = { arg => [] } unless arg.is_a?(Hash)
+            hash.merge!(arg)
+          end
+
+          condition_type = new_processors.keys.detect { |key| [:if, :unless].include?(key) }
+          condition = new_processors.delete(:if) || new_processors.delete(:unless)
+          new_processors.each do |processor, processor_args|
+            self.processors += [[processor, processor_args, condition, condition_type]]
+
+            if processor == :convert
+              # Treat :convert specially, since it should trigger the file extension change
+              force_extension processor_args
+              if condition
+                warn "Use of 'process convert: format' with conditionals has an issue and doesn't work correctly. See https://github.com/carrierwaveuploader/carrierwave/issues/2723 for details. "
+              end
+            end
+          end
+        end
+      end # ClassMethods
+
+      ##
+      # Apply all process callbacks added through CarrierWave.process
+      #
+      def process!(new_file=nil)
+        return unless enable_processing
+
+        with_callbacks(:process, new_file) do
+          self.class.processors.each do |method, args, condition, condition_type|
+            if condition && condition_type == :if
+              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
+            elsif condition && condition_type == :unless
+              if condition.respond_to?(:call)
+                next if condition.call(self, :args => args, :method => method, :file => new_file)
+              elsif self.send(condition, new_file)
+                next
+              end
+            end
+
+            if args.is_a? Array
+              kwargs, args = args.partition { |arg| arg.is_a? Hash }
+            end
+
+            if kwargs.present?
+              kwargs = kwargs.reduce(:merge)
+              self.send(method, *args, **kwargs)
+            else
+              self.send(method, *args)
+            end
+          end
+        end
+      end
+
+    private
+
+      def forcing_extension(filename)
+        if force_extension && filename
+          Pathname.new(filename).sub_ext(".#{force_extension.to_s.delete_prefix('.')}").to_s
+        else
+          filename
+        end
+      end
+    end # Processing
+  end # Uploader
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/uploader/proxy.rb

@@ -0,0 +1,99 @@
+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 retrieved or last stored file
+      #
+      # === Returns
+      #
+      # [String] uniquely identifies a file
+      #
+      def identifier
+        @identifier || (file && storage.try(:identifier))
+      end
+
+      ##
+      # Returns a String which is to be used as a temporary value which gets assigned to the column.
+      # The purpose is to mark the column that it will be updated. Finally before the save it will be
+      # overwritten by the #identifier value, which is usually #filename.
+      #
+      # === Returns
+      #
+      # [String] a temporary_identifier, by default the value of #cache_name is used
+      #
+      def temporary_identifier
+        cache_name || @identifier
+      end
+
+      ##
+      # Read the contents of the file
+      #
+      # === Returns
+      #
+      # [String] contents of the file
+      #
+      def read(*args)
+        file.try(:read, *args)
+      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/carrierwave-3.1.3/lib/carrierwave/uploader/remove.rb

@@ -0,0 +1,21 @@
+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/carrierwave-3.1.3/lib/carrierwave/uploader/serialization.rb

@@ -0,0 +1,28 @@
+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.to_s, { "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/carrierwave-3.1.3/lib/carrierwave/uploader/store.rb

@@ -0,0 +1,168 @@
+module CarrierWave
+  module Uploader
+    module Store
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+      include CarrierWave::Uploader::Configuration
+      include CarrierWave::Uploader::Cache
+
+      included do
+        prepend Module.new {
+          def initialize(*)
+            super
+            @file, @filename, @cache_id, @identifier, @deduplication_index = nil
+          end
+        }
+
+        after :store, :show_warning_when_filename_is_unavailable
+
+        class_attribute :filename_safeguard_checked
+      end
+
+      module ClassMethods
+      private
+
+        def inherited(subclass)
+          # To perform the filename safeguard check once per a class
+          self.filename_safeguard_checked = false
+          super
+        end
+      end
+
+      ##
+      # 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
+
+      ##
+      # Returns a filename which doesn't conflict with already-stored files.
+      #
+      # === Returns
+      #
+      # [String] the filename with suffix added for deduplication
+      #
+      def deduplicated_filename
+        return unless filename
+        return filename unless @deduplication_index
+
+        parts = filename.split('.')
+        basename = parts.shift
+        basename.sub!(/ ?\(\d+\)\z/, '')
+        ([basename.to_s + (@deduplication_index > 1 ? "(#{@deduplication_index})" : '')] + parts).join('.')
+      end
+
+      ##
+      # Calculates the path where the file should be stored. If +for_file+ is given, it will be
+      # used as the identifier, otherwise +CarrierWave::Uploader#identifier+ is assumed.
+      #
+      # === Parameters
+      #
+      # [for_file (String)] name of the file <optional>
+      #
+      # === Returns
+      #
+      # [String] the store path
+      #
+      def store_path(for_file=identifier)
+        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 && !cached?
+        if !cache_only && @file && @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
+            @identifier = storage.identifier
+            @original_filename = @cache_id = @deduplication_index = nil
+            @staged = false
+          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)
+          @identifier = identifier
+        end
+      end
+
+      ##
+      # Look for an identifier which doesn't collide with the given already-stored identifiers.
+      # It is done by adding a index number as the suffix.
+      # For example, if there's 'image.jpg' and the @deduplication_index is set to 2,
+      # The stored file will be named as 'image(2).jpg'.
+      #
+      # === Parameters
+      #
+      # [current_identifiers (Array[String])] List of identifiers for already-stored files
+      #
+      def deduplicate(current_identifiers)
+        @deduplication_index = nil
+        return unless current_identifiers.include?(identifier)
+
+        (1..current_identifiers.size + 1).each do |i|
+          @deduplication_index = i
+          break unless current_identifiers.include?(identifier)
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        forcing_extension(for_file)
+      end
+
+      def show_warning_when_filename_is_unavailable(_)
+        return if self.class.filename_safeguard_checked
+        self.class.filename_safeguard_checked = true
+        return if filename
+
+        warn <<~MESSAGE
+          [WARNING] Your uploader's #filename method defined at #{method(:filename).source_location.join(':')} didn't return value after storing the file.
+          It's likely that the method is safeguarded with `if original_filename`, which were necessary for pre-3.x CarrierWave but is no longer needed.
+          Removing it is recommended, as it is known to cause issues depending on the use case: https://github.com/carrierwaveuploader/carrierwave/issues/2708
+        MESSAGE
+      end
+
+      def storage
+        @storage ||= self.class.storage.new(self)
+      end
+
+    end # Store
+  end # Uploader
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/uploader/url.rb

@@ -0,0 +1,44 @@
+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)
+          tmp_url = file.method(:url).arity.zero? ? file.url : file.url(options)
+          return tmp_url if tmp_url.present?
+        end
+
+        if 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