shrine 2.19.3 → 3.6.0

data/lib/shrine/plugins/type_predicates.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/type_predicates
+    module TypePredicates
+      def self.configure(uploader, methods: [], **opts)
+        uploader.opts[:type_predicates] ||= { mime: :mini_mime }
+        uploader.opts[:type_predicates].merge!(opts)
+
+        methods.each do |name|
+          uploader::UploadedFile.send(:define_method, "#{name}?") { type?(name) }
+        end
+      end
+
+      module ClassMethods
+        def type_lookup(extension, database = nil)
+          database ||= opts[:type_predicates][:mime]
+          database   = MimeDatabase.new(database) if database.is_a?(Symbol)
+          database.call(extension.to_s)
+        end
+      end
+
+      module FileMethods
+        def image?
+          general_type?("image")
+        end
+
+        def video?
+          general_type?("video")
+        end
+
+        def audio?
+          general_type?("audio")
+        end
+
+        def text?
+          general_type?("text")
+        end
+
+        def type?(type)
+          matching_mime_type = shrine_class.type_lookup(type)
+
+          fail Error, "type #{type.inspect} is not recognized by the MIME library" unless matching_mime_type
+
+          mime_type! == matching_mime_type
+        end
+
+        private
+
+        def general_type?(type)
+          mime_type!.start_with?(type)
+        end
+
+        def mime_type!
+          mime_type or fail Error, "mime_type metadata value is missing"
+        end
+      end
+
+      class MimeDatabase
+        SUPPORTED_TOOLS = %i[mini_mime mime_types mimemagic marcel rack_mime]
+
+        def initialize(tool)
+          raise Error, "unknown type database #{tool.inspect}, supported databases are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
+
+          @tool = tool
+        end
+
+        def call(extension)
+          send(:"lookup_with_#{@tool}", extension)
+        end
+
+        private
+
+        def lookup_with_mini_mime(extension)
+          require "mini_mime"
+
+          info = MiniMime.lookup_by_extension(extension)
+          info&.content_type
+        end
+
+        def lookup_with_mime_types(extension)
+          require "mime/types"
+
+          mime_type = MIME::Types.of(".#{extension}").first
+          mime_type&.content_type
+        end
+
+        def lookup_with_mimemagic(extension)
+          require "mimemagic"
+
+          magic = MimeMagic.by_extension(".#{extension}")
+          magic&.type
+        end
+
+        def lookup_with_marcel(extension)
+          require "marcel"
+
+          type = Marcel::MimeType.for(extension: ".#{extension}")
+          type unless type == "application/octet-stream"
+        end
+
+        def lookup_with_rack_mime(extension)
+          require "rack/mime"
+
+          Rack::Mime.mime_type(".#{extension}", nil)
+        end
+      end
+    end
+
+    register_plugin(:type_predicates, TypePredicates)
+  end
+end

data/lib/shrine/plugins/upload_endpoint.rb

@@ -7,15 +7,13 @@ require "digest"
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/upload_endpoint.md] on GitHub.
-    #
-    # [doc/plugins/upload_endpoint.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/upload_endpoint.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/upload_endpoint
     module UploadEndpoint
-      def self.load_dependencies(uploader, opts = {})
+      def self.load_dependencies(uploader, **)
         uploader.plugin :rack_file
       end
 
-      def self.configure(uploader, opts = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:upload_endpoint] ||= {}
         uploader.opts[:upload_endpoint].merge!(opts)
       end
@@ -93,7 +91,9 @@ class Shrine
         handle_request(request)
       end
 
-      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      headers = Rack::Headers[headers] if Rack.release >= "3"
+      headers["Content-Length"] ||= body.respond_to?(:bytesize) ? body.bytesize.to_s :
+                                                                  body.map(&:bytesize).inject(0, :+).to_s
 
       [status, headers, body]
     end
@@ -137,16 +137,21 @@ class Shrine
       end
 
       error!(400, "Upload Not Found") if value.nil?
-      error!(400, "Upload Not Valid") unless value.is_a?(Hash) && value[:tempfile]
 
-      @shrine_class.rack_file(value)
+      if value.is_a?(Hash) && value[:tempfile]
+        @shrine_class.rack_file(value)
+      elsif %i[read rewind eof? close].all? { |m| value.respond_to?(m) }
+        value
+      else
+        error!(400, "Upload Not Valid")
+      end
     end
 
     # Returns a hash of information containing `:action` and `:request`
     # keys, which is to be passed to `Shrine#upload`. Calls
     # `:upload_context` option if given.
     def get_context(request)
-      context = { action: :upload, phase: :upload, request: request }
+      context = { action: :upload }
       context.merge! @upload_context.call(request) if @upload_context
       context
     end
@@ -158,7 +163,7 @@ class Shrine
       if @upload
         @upload.call(io, context, request)
       else
-        uploader.upload(io, context)
+        uploader.upload(io, **context)
       end
     end
 
@@ -166,26 +171,29 @@ class Shrine
     # a Rack response triple - an array consisting of a status number, hash
     # of headers, and a body enumerable. If a `:rack_response` option is
     # given, calls that instead.
-    def make_response(object, request)
+    def make_response(uploaded_file, request)
       if @rack_response
-        @rack_response.call(object, request)
+        @rack_response.call(uploaded_file, request)
       else
         if @url
-          url = case @url
-                when true then object.url
-                when Hash then object.url(**@url)
-                else           @url.call(object, request)
-                end
-
-          body = { data: object, url: url }.to_json
+          url  = resolve_url(uploaded_file, request)
+          body = { data: uploaded_file, url: url }.to_json
         else
-          body = object.to_json
+          body = uploaded_file.to_json
         end
 
         [200, { "Content-Type" => CONTENT_TYPE_JSON }, [body]]
       end
     end
 
+    def resolve_url(uploaded_file, request)
+      case @url
+      when true then uploaded_file.url
+      when Hash then uploaded_file.url(**@url)
+      else           @url.call(uploaded_file, request)
+      end
+    end
+
     def verify_size!(file, request)
       error!(413, "Upload Too Large") if @max_size && file.size > @max_size
     end
@@ -212,8 +220,4 @@ class Shrine
       @shrine_class.new(@storage_key)
     end
   end
-
-  # backwards compatibility
-  Plugins::UploadEndpoint.const_set(:App, UploadEndpoint)
-  Plugins::UploadEndpoint.deprecate_constant(:App)
 end

data/lib/shrine/plugins/upload_options.rb

@@ -2,28 +2,27 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/upload_options.md] on GitHub.
-    #
-    # [doc/plugins/upload_options.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/upload_options.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/upload_options
     module UploadOptions
-      def self.configure(uploader, options = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:upload_options] ||= {}
-        uploader.opts[:upload_options].merge!(options)
+        uploader.opts[:upload_options].merge!(opts)
       end
 
       module InstanceMethods
-        def put(io, context)
-          upload_options = get_upload_options(io, context)
-          context = { upload_options: upload_options }.merge(context)
-          super
-        end
-
         private
 
-        def get_upload_options(io, context)
-          options = opts[:upload_options][storage_key]
-          options = options.call(io, context) if options.respond_to?(:call)
-          options
+        def _upload(io, **options)
+          upload_options = get_upload_options(io, options)
+
+          super(io, **options, upload_options: upload_options)
+        end
+
+        def get_upload_options(io, options)
+          upload_options = opts[:upload_options][storage_key] || {}
+          upload_options = upload_options.call(io, options) if upload_options.respond_to?(:call)
+          upload_options = upload_options.merge(options[:upload_options]) if options[:upload_options]
+          upload_options
         end
       end
     end

data/lib/shrine/plugins/url_options.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/url_options
+    module UrlOptions
+      def self.configure(uploader, **opts)
+        uploader.opts[:url_options] ||= {}
+        uploader.opts[:url_options].merge!(opts)
+      end
+
+      module FileMethods
+        def url(**options)
+          default_options = url_options(options)
+
+          super(**default_options, **options)
+        end
+
+        private
+
+        def url_options(options)
+          default_options = shrine_class.opts[:url_options][storage_key]
+          default_options = default_options.call(self, options) if default_options.respond_to?(:call)
+          default_options || {}
+        end
+      end
+    end
+
+    register_plugin(:url_options, UrlOptions)
+  end
+end

data/lib/shrine/plugins/validation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/validation
+    module Validation
+      module AttacherClassMethods
+        # Block that is executed in context of Shrine::Attacher during
+        # validation. Example:
+        #
+        #     Shrine::Attacher.validate do
+        #       if file.size > 5*1024*1024
+        #         errors << "is too big (max is 5 MB)"
+        #       end
+        #     end
+        def validate(&block)
+          private define_method(:validate_block, &block)
+        end
+      end
+
+      module AttacherMethods
+        # Returns an array of validation errors created on file assignment in
+        # the `Attacher.validate` block.
+        attr_reader :errors
+
+        # Initializes validation errors to an empty array.
+        def initialize(**options)
+          super
+          @errors = []
+        end
+
+        # Performs validations after attaching cached file.
+        def attach_cached(value, validate: nil, **options)
+          result = super(value, validate: false, **options)
+          validation(validate)
+          result
+        end
+
+        # Performs validations after attaching file.
+        def attach(io, validate: nil, **options)
+          result = super(io, **options)
+          validation(validate)
+          result
+        end
+
+        # Runs the validation defined by `Attacher.validate`.
+        def validate(**options)
+          errors.clear
+          _validate(**options) if attached?
+        end
+
+        private
+
+        # Calls validation appropriately based on the :validate value.
+        def validation(argument)
+          case argument
+          when Hash  then validate(**argument)
+          when false then errors.clear # skip validation
+          else            validate
+          end
+        end
+
+        # Calls #validate_block, passing it accepted parameters.
+        def _validate(**options)
+          if method(:validate_block).arity.zero?
+            validate_block
+          else
+            validate_block(**options)
+          end
+        end
+
+        # Overridden by the `Attacher.validate` block.
+        def validate_block(**options)
+        end
+      end
+    end
+
+    register_plugin(:validation, Validation)
+  end
+end

data/lib/shrine/plugins/validation_helpers.rb

@@ -2,15 +2,8 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/validation_helpers.md] on GitHub.
-    #
-    # [doc/plugins/validation_helpers.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/validation_helpers.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/validation_helpers
     module ValidationHelpers
-      def self.configure(uploader, opts = {})
-        uploader.opts[:validation_default_messages] ||= {}
-        uploader.opts[:validation_default_messages].merge!(opts[:default_messages] || {})
-      end
-
       DEFAULT_MESSAGES = {
         max_size:            -> (max)  { "size must not be greater than #{PRETTY_FILESIZE.call(max)}" },
         min_size:            -> (min)  { "size must not be less than #{PRETTY_FILESIZE.call(min)}" },
@@ -24,7 +17,7 @@ class Shrine
         mime_type_exclusion: -> (list) { "type must not be one of: #{list.join(", ")}" },
         extension_inclusion: -> (list) { "extension must be one of: #{list.join(", ")}" },
         extension_exclusion: -> (list) { "extension must not be one of: #{list.join(", ")}" },
-      }
+      }.freeze
 
       FILESIZE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"].freeze
 
@@ -39,10 +32,18 @@ class Shrine
         "%.1f %s" % [bytes.to_f / 1024 ** exp, FILESIZE_UNITS[exp]]
       end
 
+      def self.load_dependencies(uploader, *)
+        uploader.plugin :validation
+      end
+
+      def self.configure(uploader, default_messages: {}, **opts)
+        uploader.opts[:validation_helpers] ||= { default_messages: DEFAULT_MESSAGES.dup }
+        uploader.opts[:validation_helpers][:default_messages].merge!(default_messages)
+      end
+
       module AttacherClassMethods
         def default_validation_messages
-          @default_validation_messages ||= DEFAULT_MESSAGES.merge(
-            shrine_class.opts[:validation_default_messages])
+          shrine_class.opts[:validation_helpers][:default_messages]
         end
       end
 
@@ -51,14 +52,14 @@ class Shrine
         #
         #     validate_max_size 5*1024*1024
         def validate_max_size(max, message: nil)
-          validate_result(get.size <= max, :max_size, message, max)
+          validate_result(file.size <= max, :max_size, message, max)
         end
 
         # Validates that the `size` metadata is not smaller than `min`.
         #
         #     validate_min_size 1024
         def validate_min_size(min, message: nil)
-          validate_result(get.size >= min, :min_size, message, min)
+          validate_result(file.size >= min, :min_size, message, min)
         end
 
         # Validates that the `size` metadata is in the given range.
@@ -76,12 +77,9 @@ class Shrine
         #
         #     validate_max_width 5000
         def validate_max_width(max, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
-          if get.width
-            validate_result(get.width <= max, :max_width, message, max)
-          else
-            Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
-          end
+          fail Error, "width metadata is missing" unless file["width"]
+
+          validate_result(file["width"] <= max, :max_width, message, max)
         end
 
         # Validates that the `width` metadata is not smaller than `min`.
@@ -89,12 +87,9 @@ class Shrine
         #
         #     validate_min_width 100
         def validate_min_width(min, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
-          if get.width
-            validate_result(get.width >= min, :min_width, message, min)
-          else
-            Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
-          end
+          fail Error, "width metadata is missing" unless file["width"]
+
+          validate_result(file["width"] >= min, :min_width, message, min)
         end
 
         # Validates that the `width` metadata is in the given range.
@@ -112,12 +107,9 @@ class Shrine
         #
         #     validate_max_height 5000
         def validate_max_height(max, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
-          if get.height
-            validate_result(get.height <= max, :max_height, message, max)
-          else
-            Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
-          end
+          fail Error, "height metadata is missing" unless file["height"]
+
+          validate_result(file["height"] <= max, :max_height, message, max)
         end
 
         # Validates that the `height` metadata is not smaller than `min`.
@@ -125,12 +117,9 @@ class Shrine
         #
         #     validate_min_height 100
         def validate_min_height(min, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
-          if get.height
-            validate_result(get.height >= min, :min_height, message, min)
-          else
-            Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
-          end
+          fail Error, "height metadata is missing" unless file["height"]
+
+          validate_result(file["height"] >= min, :min_height, message, min)
         end
 
         # Validates that the `height` metadata is in the given range.
@@ -146,24 +135,22 @@ class Shrine
         #
         #     validate_max_dimensions [5000, 5000]
         def validate_max_dimensions((max_width, max_height), message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
-          fail Error, "width or height metadata is nil" unless get.width && get.height
+          fail Error, "width and/or height metadata is missing" unless file["width"] && file["height"]
 
           validate_result(
-            get.width <= max_width && get.height <= max_height,
+            file["width"] <= max_width && file["height"] <= max_height,
             :max_dimensions, message, [max_width, max_height]
           )
         end
 
         # Validates that the dimensions are not smaller than specified.
         #
-        #     validate_max_dimensions [100, 100]
+        #     validate_min_dimensions [100, 100]
         def validate_min_dimensions((min_width, min_height), message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
-          fail Error, "width or height metadata is nil" unless get.width && get.height
+          fail Error, "width and/or height metadata is missing" unless file["width"] && file["height"]
 
           validate_result(
-            get.width >= min_width && get.height >= min_height,
+            file["width"] >= min_width && file["height"] >= min_height,
             :min_dimensions, message, [min_width, min_height]
           )
         end
@@ -184,7 +171,7 @@ class Shrine
         #     validate_mime_type_inclusion %w[audio/mp3 audio/flac]
         def validate_mime_type_inclusion(types, message: nil)
           validate_result(
-            types.any? { |type| regex(type) =~ get.mime_type.to_s },
+            types.include?(file.mime_type),
             :mime_type_inclusion, message, types
           )
         end
@@ -196,7 +183,7 @@ class Shrine
         #     validate_mime_type_exclusion %w[text/x-php]
         def validate_mime_type_exclusion(types, message: nil)
           validate_result(
-            types.none? { |type| regex(type) =~ get.mime_type.to_s },
+            !types.include?(file.mime_type),
             :mime_type_exclusion, message, types
           )
         end
@@ -207,7 +194,7 @@ class Shrine
         #     validate_extension_inclusion %w[jpg jpeg png gif]
         def validate_extension_inclusion(extensions, message: nil)
           validate_result(
-            extensions.any? { |extension| regex(extension) =~ get.extension.to_s },
+            extensions.any? { |extension| extension.casecmp(file.extension.to_s) == 0 },
             :extension_inclusion, message, extensions
           )
         end
@@ -219,7 +206,7 @@ class Shrine
         #     validate_extension_exclusion %[php jar]
         def validate_extension_exclusion(extensions, message: nil)
           validate_result(
-            extensions.none? { |extension| regex(extension) =~ get.extension.to_s },
+            extensions.none? { |extension| extension.casecmp(file.extension.to_s) == 0 },
             :extension_exclusion, message, extensions
           )
         end
@@ -236,16 +223,6 @@ class Shrine
           end
         end
 
-        # Converts a string to a regex.
-        def regex(value)
-          if value.is_a?(Regexp)
-            Shrine.deprecation("Passing regexes to type/extension whitelists/blacklists in validation_helpers plugin is deprecated and will be removed in Shrine 3. Use strings instead.")
-            value
-          else
-            /\A#{Regexp.escape(value)}\z/i
-          end
-        end
-
         # Generates an error message and appends it to errors array.
         def add_error(*args)
           errors << error_message(*args)