mini_paperclip 0.1.0

data/lib/mini_paperclip/shoulda/matchers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "mini_paperclip/shoulda/matchers/have_attached_file_matcher"
+require "mini_paperclip/shoulda/matchers/validate_attachment_content_type_matcher"
+require "mini_paperclip/shoulda/matchers/validate_attachment_geometry_matcher"
+require "mini_paperclip/shoulda/matchers/validate_attachment_presence_matcher"
+require "mini_paperclip/shoulda/matchers/validate_attachment_size_matcher"

data/lib/mini_paperclip/shoulda/matchers/have_attached_file_matcher.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class has an attachment with the
+      # given name.
+      #
+      # Example:
+      #   describe User do
+      #     it { should have_attached_file(:avatar) }
+      #   end
+      def have_attached_file name
+        HaveAttachedFileMatcher.new(name)
+      end
+
+      class HaveAttachedFileMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+        end
+
+        def matches? subject
+          @subject = subject.class == Class ? subject.new : subject
+
+          @subject.respond_to?(@attachment_name) &&
+            @subject.respond_to?("#{@attachment_name}=") &&
+            @subject.public_send(@attachment_name).kind_of?(MiniPaperclip::Attachment) &&
+            @subject.class.column_names.include?("#{@attachment_name}_file_name")
+        end
+
+        def failure_message
+          "Should have an attachment named #{@attachment_name}"
+        end
+
+        def failure_message_when_negated
+          "Should not have an attachment named #{@attachment_name}"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "have an attachment named #{@attachment_name}"
+        end
+      end
+    end
+  end
+end

data/lib/mini_paperclip/shoulda/matchers/validate_attachment_content_type_matcher.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the content type of
+      # the given attachment as specified.
+      #
+      # Example:
+      #   describe User do
+      #     it { should validate_attachment_content_type(:icon).
+      #                   allowing('image/png', 'image/gif').
+      #                   rejecting('text/plain', 'text/xml') }
+      #   end
+      def validate_attachment_content_type(attachment_name)
+        ValidateAttachmentContentTypeMatcher.new(attachment_name)
+      end
+
+      class ValidateAttachmentContentTypeMatcher
+        def initialize(attachment_name)
+          @attachment_name = attachment_name.to_sym
+          @allowings = []
+          @rejectings = []
+          @fails = []
+        end
+
+        def allowing(*allowings)
+          @allowings.concat(allowings)
+          self
+        end
+
+        def rejecting(*rejectings)
+          @rejectings.concat(rejectings)
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject.class == Class ? subject.new : subject
+
+          begin
+            fails = @allowings.reject do |allowing|
+              @subject.write_attribute("#{@attachment_name}_content_type", allowing)
+              @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+              @subject.valid?
+              @subject.errors[:"#{@attachment_name}_content_type"].empty?
+            end
+            @fails.concat(fails).empty?
+          end && begin
+            fails = @rejectings.reject do |rejecting|
+              @subject.write_attribute("#{@attachment_name}_content_type", rejecting)
+              @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+              @subject.valid?
+              @subject.errors[:"#{@attachment_name}_content_type"].present?
+            end
+            @fails.concat(fails).empty?
+          end
+        end
+
+        def failure_message
+          [
+            "Attachment :#{@attachment_name} expected to",
+            "  allowing #{@allowings}",
+            "  rejecting #{@rejectings}",
+            "  but failed #{@fails}"
+          ].join("\n")
+        end
+
+        def failure_message_when_negated
+          [
+            "Attachment :#{@attachment_name} NOT expected to",
+            "  allowing #{@allowings}",
+            "  rejecting #{@rejectings}",
+            "  but failed #{@fails}"
+          ].join("\n")
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "validate the content types allowed on attachment :#{@attachment_name}"
+        end
+      end
+    end
+  end
+end

data/lib/mini_paperclip/shoulda/matchers/validate_attachment_geometry_matcher.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the geometry of
+      # the given attachment as specified.
+      #
+      # Example:
+      #   describe User do
+      #     it { should validate_attachment_geometry(:icon)
+      #                   .format(:png)
+      #                   .width(less_than_or_equal_to: 100)
+      #                   .height(less_than_or_equal_to: 100)
+      #   end
+      def validate_attachment_geometry(attachment_name)
+        ValidateAttachmentGeometryMatcher.new(attachment_name)
+      end
+
+      class ValidateAttachmentGeometryMatcher
+        CallError = Class.new(StandardError)
+
+        def initialize(attachment_name)
+          @attachment_name = attachment_name.to_sym
+          @width = {}
+          @height = {}
+          @format = nil
+        end
+
+        def format(format)
+          @format = format
+          self
+        end
+
+        def width(less_than_or_equal_to:)
+          @width[:less_than_or_equal_to] = less_than_or_equal_to
+          self
+        end
+
+        def height(less_than_or_equal_to:)
+          @height[:less_than_or_equal_to] = less_than_or_equal_to
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject.class == Class ? subject.new : subject
+
+          unless @format && !@width.empty? && !@height.empty?
+            raise CallError, [
+              "should call like this",
+              "  it { should validate_attachment_geometry(:image)",
+              "                .format(:png)",
+              "                .width(less_than_or_equal_to: 3000)",
+              "                .height(less_than_or_equal_to: 3000) }"
+            ].join("\n")
+          end
+
+          when_valid && when_invalid
+        end
+
+        def failure_message
+          [
+            "Attachment :#{@attachment_name} got details",
+            @subject.errors.details[@attachment_name]
+          ].join("\n")
+        end
+
+        def failure_message_when_negated
+          [
+            "Attachment :#{@attachment_name} got details",
+            @subject.errors.details[@attachment_name]
+          ].join("\n")
+        end
+
+        private
+
+        def when_valid
+          create_dummy_image(width: @width[:less_than_or_equal_to], height: @height[:less_than_or_equal_to]) do |f|
+            @subject.public_send("#{@attachment_name}=", f)
+          end
+          @subject.valid?
+          @subject.errors.details[:image]&.find { |d| d[:error] == :geometry }.nil?
+        end
+
+        def when_invalid
+          create_dummy_image(width: @width[:less_than_or_equal_to] + 1, height: @height[:less_than_or_equal_to] + 1) do |f|
+            @subject.public_send("#{@attachment_name}=", f)
+          end
+          @subject.valid?
+          detail = @subject.errors.details[:image]&.find { |d| d[:error] == :geometry }
+          return false unless detail
+          return false unless detail[:expected_width_less_than_or_equal_to] == @width[:less_than_or_equal_to]
+          return false unless detail[:expected_height_less_than_or_equal_to] == @height[:less_than_or_equal_to]
+          true
+        end
+
+        def create_dummy_image(width:, height:)
+          Tempfile.create(['MiniPaperclip::Shoulda::Matchers::ValidateAttachmentGeometryMatcher', ".#{@format}"]) do |f|
+            MiniMagick::Tool::Convert.new do |convert|
+              convert.size("#{width}x#{height}")
+              convert.xc("none")
+              convert.strip
+              convert << f.path
+            end
+            yield f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mini_paperclip/shoulda/matchers/validate_attachment_presence_matcher.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the presence of the
+      # given attachment.
+      #
+      # describe User do
+      #   it { should validate_attachment_presence(:avatar) }
+      # end
+      def validate_attachment_presence(attachment_name)
+        ValidateAttachmentPresenceMatcher.new(attachment_name)
+      end
+
+      class ValidateAttachmentPresenceMatcher
+        def initialize(attachment_name)
+          @attachment_name = attachment_name.to_sym
+        end
+
+        def matches?(subject)
+          @subject = subject.class == Class ? subject.new : subject
+
+          begin
+            @subject.write_attribute("#{@attachment_name}_file_name", 'hello.png')
+            @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+            @subject.valid?
+            @subject.errors[@attachment_name].empty?
+          end && begin
+            @subject.write_attribute("#{@attachment_name}_file_name", nil)
+            @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+            @subject.valid?
+            @subject.errors[@attachment_name].present?
+          end
+        end
+
+        def failure_message
+          "Attachment :#{@attachment_name} should be required"
+        end
+
+        def failure_message_when_negated
+          "Attachment :#{@attachment_name} should not be required"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "require presence of attachment :#{@attachment_name}"
+        end
+      end
+    end
+  end
+end

data/lib/mini_paperclip/shoulda/matchers/validate_attachment_size_matcher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the size of the
+      # given attachment as specified.
+      #
+      # Examples:
+      #   it { should validate_attachment_size(:avatar).
+      #                 less_than(2.megabytes) }
+      def validate_attachment_size(attachment_name)
+        ValidateAttachmentSizeMatcher.new(attachment_name)
+      end
+
+      class ValidateAttachmentSizeMatcher
+        def initialize(attachment_name)
+          @attachment_name = attachment_name.to_sym
+          @less_than_size = nil
+        end
+
+        def less_than(less_than_size)
+          @less_than_size = less_than_size
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject.class == Class ? subject.new : subject
+
+          begin
+            @subject.write_attribute("#{@attachment_name}_file_size", @less_than_size - 1)
+            @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+            @subject.valid?
+            @subject.errors[:"#{@attachment_name}_file_size"].empty?
+          end && begin
+            @subject.write_attribute("#{@attachment_name}_file_size", @less_than_size)
+            @subject.write_attribute("#{@attachment_name}_updated_at", Time.now)
+            @subject.valid?
+            @subject.errors[:"#{@attachment_name}_file_size"].present?
+          end
+        end
+
+        def failure_message
+          "Attachment :#{@attachment_name} should be less than #{human_size}"
+        end
+
+        def failure_message_when_negated
+          "Attachment :#{@attachment_name} should not be less than #{human_size}"
+        end
+        alias negative_failure_message failure_message_when_negated
+
+        def description
+          "validate the size of attachment :#{@attachment_name}"
+        end
+
+        def human_size
+          ActiveSupport::NumberHelper.number_to_human_size(@less_than_size)
+        end
+      end
+    end
+  end
+end

data/lib/mini_paperclip/storage.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "mini_paperclip/storage/base"
+require "mini_paperclip/storage/filesystem"
+require "mini_paperclip/storage/s3"

data/lib/mini_paperclip/storage/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Storage
+    class Base
+      attr_reader :config
+
+      def initialize(record, attachment_name, config)
+        @record = record
+        @attachment_name = attachment_name
+        @config = config
+        @interpolator = Interpolator.new(record, attachment_name, config)
+      end
+
+      def url_for_read(style)
+        "#{@config.url_scheme}://#{host}/#{path_for(style)}"
+      end
+
+      def path_for(style)
+        template = if @record.public_send(@attachment_name)&.file?
+          @config.url_path
+        else
+          @config.url_missing_path
+        end
+        interpolate(template, style)
+      end
+
+      def interpolate(template, style)
+        @interpolator.interpolate(template, style)
+      end
+
+      private
+
+      def debug(str)
+        MiniPaperclip.config.logger.debug(str)
+      end
+    end
+  end
+end

data/lib/mini_paperclip/storage/filesystem.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module MiniPaperclip
+  module Storage
+    class Filesystem < Base
+      def write(style, file)
+        path = file_path(style)
+        debug("writing by filesystem to #{path}")
+        FileUtils.mkdir_p(File.dirname(path))
+        FileUtils.cp(file.path, path)
+      end
+
+      def copy(style, from_attachment)
+        raise "not supported" unless from_attachment.storage.instance_of?(Filesystem)
+        to_path = file_path(style)
+        from_path = from_attachment.storage.file_path(style)
+        debug("copying by filesystem from:#{from_path} to:#{to_path}")
+        FileUtils.cp(from_path, to_path)
+      end
+
+      def file_path(style)
+        interpolate(@config.filesystem_path, style)
+      end
+
+      def host
+        @config.url_host
+      end
+
+      def exists?(style)
+        File.exists?(file_path(style))
+      end
+    end
+  end
+end