{"record":{"id":"e12a3c6f0d860abe","repo":"carrierwaveuploader/carrierwave","slug":"errors-messages-min-size-error","errorCode":null,"errorMessage":"errors.messages.min_size_error","messagePattern":"errors\\.messages\\.min_size_error","errorType":"exception","errorClass":"CarrierWave::IntegrityError","httpStatus":null,"severity":"error","filePath":"lib/carrierwave/uploader/file_size.rb","lineNumber":34,"sourceCode":"      #\n      # [NilClass, Range] a size range (in bytes) which are permitted to be uploaded\n      #\n      # === Examples\n      #\n      #     def size_range\n      #       3256...5748\n      #     end\n      #\n      def size_range; end\n\n    private\n\n      def check_size!(new_file)\n        size = new_file.size\n        expected_size_range = size_range\n        if expected_size_range.is_a?(::Range)\n          if size < expected_size_range.min\n            raise CarrierWave::IntegrityError, I18n.translate(:\"errors.messages.min_size_error\", :min_size => ActiveSupport::NumberHelper.number_to_human_size(expected_size_range.min))\n          elsif size > expected_size_range.max\n            raise CarrierWave::IntegrityError, I18n.translate(:\"errors.messages.max_size_error\", :max_size => ActiveSupport::NumberHelper.number_to_human_size(expected_size_range.max))\n          end\n        end\n      end\n\n    end # FileSize\n  end # Uploader\nend # CarrierWave\n","sourceCodeStart":16,"sourceCodeEnd":44,"githubUrl":"https://github.com/carrierwaveuploader/carrierwave/blob/b5f0abe10ecf6500309fc83e0e8969cf57ba690e/lib/carrierwave/uploader/file_size.rb#L16-L44","documentation":"CarrierWave raises CarrierWave::IntegrityError with this message from the `before :cache` callback `check_size!` when the uploaded file is smaller than the minimum of the Range returned by the uploader's `size_range` (values are bytes). The check only runs if `size_range` returns an actual `::Range`; the minimum is formatted for humans with `number_to_human_size` before the error is raised. It fires during caching, i.e. the moment a file is assigned to the mounted attribute.","triggerScenarios":"Defining `def size_range; 1.megabyte..5.megabytes; end` in the uploader and assigning a file of, say, 300 KB (`new_file.size < range.min`). Typical with minimum-quality rules (e.g. avatar must be at least 1 MB) or ranges written as an exact size rather than an interval.","commonSituations":"`size_range` set to enforce a maximum only (e.g. `5.megabytes..10.megabytes`) when the intent was `0..5.megabytes`, so every small file is rejected; tiny auto-generated files (1x1 pixel placeholders, empty PDFs) failing an aggressive minimum after a policy change; teams surprised that a 'max size' upload rule also rejects small files because the Range has a non-zero min.","solutions":["Lower the minimum of `size_range` — if you only want a maximum, write `0..5.megabytes` (or `nil..max` is not valid; use 0 as min).","Confirm the actual byte size being rejected (`file.size`, or the browser's File.size) against the range; remember values are bytes, not kilobytes.","If a real floor is intended, communicate it in the UI (accept/min-size hints) and validate client-side before the POST.","Rescue `CarrierWave::IntegrityError` where the attribute is assigned and convert the message into a model/user-facing validation message."],"exampleFix":"# before\nclass AvatarUploader < CarrierWave::Uploader::Base\n  def size_range\n    1.megabyte..5.megabytes\n  end\nend\n# uploading a 300 KB avatar => CarrierWave::IntegrityError: min_size_error\n\n# after (only a maximum was intended)\nclass AvatarUploader < CarrierWave::Uploader::Base\n  def size_range\n    0..5.megabytes\n  end\nend","handlingStrategy":"validation","validationCode":"min = 1.megabyte  # keep in sync with the uploader's size_range\nif uploaded_io.respond_to?(:size) && uploaded_io.size < min\n  errors.add(:avatar, :too_small, count: ActiveSupport::NumberHelper.number_to_human_size(min))\nend","typeGuard":null,"tryCatchPattern":"begin\n  user.avatar = params[:avatar]\nrescue CarrierWave::IntegrityError => e\n  # e.message is min_size_error with the humanized minimum\n  errors.add(:avatar, :file_too_small, message: e.message)\nend","preventionTips":["If you only mean to cap the maximum, write size_range starting at 0 (0..5.megabytes).","Store the min/max in constants referenced by both the uploader and client-side checks (File.size in JS).","Prefer allowing small files and enforcing minimum dimensions/quality at image processing time instead of a byte floor.","Unit-test size_range boundaries: min-1, min, max-1, max (and remember Ruby's ... exclusive end)."],"tags":["carrierwave","ruby","file-upload","size-validation","integrity-error"],"backgroundTag":"file-size-limit-failed","analyzedSha":"b5f0abe10ecf6500309fc83e0e8969cf57ba690e","analyzedAt":"2026-08-21T18:07:27.715Z","schemaVersion":2},"datasetVersion":"2026-08-21T18:17:14.833Z"}