salebot_uploader 1.0.0

data/lib/salebot_uploader/test/matchers.rb

@@ -0,0 +1,398 @@
+module SalebotUploader
+  module Test
+
+    ##
+    # These are some matchers that can be used in RSpec specs, to simplify the testing
+    # of uploaders.
+    #
+    module Matchers
+
+      class BeIdenticalTo # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          FileUtils.identical?(@actual, @expected)
+        end
+
+        def failure_message
+          "expected #{@actual.inspect} to be identical to #{@expected.inspect}"
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.inspect} to not be identical to #{@expected.inspect}"
+        end
+
+        def description
+          "be identical to #{@expected.inspect}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def be_identical_to(expected)
+        BeIdenticalTo.new(expected)
+      end
+
+      class HavePermissions # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          (File.stat(@actual.path).mode & 0o777) == @expected
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have permissions #{@expected.to_s(8)}, but they were #{(File.stat(@actual.path).mode & 0o777).to_s(8)}"
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to have permissions #{@expected.to_s(8)}, but it did"
+        end
+
+        def description
+          "have permissions #{@expected.to_s(8)}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def have_permissions(expected)
+        HavePermissions.new(expected)
+      end
+
+      class HaveDirectoryPermissions # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          (File.stat(File.dirname(@actual.path)).mode & 0o777) == @expected
+        end
+
+        def failure_message
+          "expected #{File.dirname @actual.current_path.inspect} to have permissions #{@expected.to_s(8)}, but they were #{(File.stat(@actual.path).mode & 0o777).to_s(8)}"
+        end
+
+        def failure_message_when_negated
+          "expected #{File.dirname @actual.current_path.inspect} not to have permissions #{@expected.to_s(8)}, but it did"
+        end
+
+        def description
+          "have permissions #{@expected.to_s(8)}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def have_directory_permissions(expected)
+        HaveDirectoryPermissions.new(expected)
+      end
+
+      class BeNoLargerThan # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_width = image.width
+          @actual_height = image.height
+          @actual_width <= @width && @actual_height <= @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to be no larger than #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} to be larger than #{@width} by #{@height}, but it wasn't."
+        end
+
+        def description
+          "be no larger than #{@width} by #{@height}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def be_no_larger_than(width, height)
+        BeNoLargerThan.new(width, height)
+      end
+
+      class HaveDimensions # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_width = image.width
+          @actual_height = image.height
+          @actual_width == @width && @actual_height == @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have an exact size of #{@width} by #{@height}, but it was #{@actual_width} by #{@actual_height}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to have an exact size of #{@width} by #{@height}, but it did."
+        end
+
+        def description
+          "have an exact size of #{@width} by #{@height}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def have_dimensions(width, height)
+        HaveDimensions.new(width, height)
+      end
+
+      class HaveHeight # :nodoc:
+        def initialize(height)
+          @height = height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_height = image.height
+          @actual_height == @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have an exact size of #{@height}, but it was #{@actual_height}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to have an exact size of #{@height}, but it did."
+        end
+
+        def description
+          "have an exact height of #{@height}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def have_height(height)
+        HaveHeight.new(height)
+      end
+
+      class HaveWidth # :nodoc:
+        def initialize(width)
+          @width = width
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_width = image.width
+          @actual_width == @width
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have an exact size of #{@width}, but it was #{@actual_width}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to have an exact size of #{@width}, but it did."
+        end
+
+        def description
+          "have an exact width of #{@width}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def have_width(width)
+        HaveWidth.new(width)
+      end
+
+      class BeNoWiderThan # :nodoc:
+        def initialize(width)
+          @width = width
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_width = image.width
+          @actual_width <= @width
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to be no wider than #{@width}, but it was #{@actual_width}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to be wider than #{@width}, but it is."
+        end
+
+        def description
+          "have a width less than or equal to #{@width}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def be_no_wider_than(width)
+        BeNoWiderThan.new(width)
+      end
+
+      class BeNoTallerThan # :nodoc:
+        def initialize(height)
+          @height = height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_height = image.height
+          @actual_height <= @height
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to be no taller than #{@height}, but it was #{@actual_height}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to be taller than #{@height}, but it is."
+        end
+
+        def description
+          "have a height less than or equal to #{@height}"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def be_no_taller_than(height)
+        BeNoTallerThan.new(height)
+      end
+
+      class BeFormat # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          image = ImageLoader.load_image(@actual.current_path)
+          @actual_expected = image.format
+          !@expected.nil? && @actual_expected.casecmp(@expected).zero?
+        end
+
+        def failure_message
+          "expected #{@actual.current_path.inspect} to have #{@expected} format, but it was #{@actual_expected}."
+        end
+
+        def failure_message_when_negated
+          "expected #{@actual.current_path.inspect} not to have #{@expected} format, but it did."
+        end
+
+        def description
+          "have #{@expected} format"
+        end
+
+        # RSpec 2 compatibility:
+        alias_method :negative_failure_message, :failure_message_when_negated
+      end
+
+      def be_format(expected)
+        BeFormat.new(expected)
+      end
+
+      class ImageLoader # :nodoc:
+        def self.load_image(filename)
+          if defined? ::MiniMagick
+            MiniMagickWrapper.new(filename)
+          else
+            unless defined? ::Magick
+              begin
+                require 'rmagick'
+              rescue LoadError
+                begin
+                  require 'RMagick'
+                rescue LoadError
+                  puts "WARNING: Failed to require rmagick, image processing may fail!"
+                end
+              end
+            end
+            MagickWrapper.new(filename)
+          end
+        end
+      end
+
+      class MagickWrapper # :nodoc:
+        attr_reader :image
+
+        def width
+          image.columns
+        end
+
+        def height
+          image.rows
+        end
+
+        def format
+          image.format
+        end
+
+        def initialize(filename)
+          @image = ::Magick::Image.read(filename).first
+        end
+      end
+
+      class MiniMagickWrapper # :nodoc:
+        attr_reader :image
+
+        def width
+          image[:width]
+        end
+
+        def height
+          image[:height]
+        end
+
+        def format
+          image[:format]
+        end
+
+        def initialize(filename)
+          @image = ::MiniMagick::Image.open(filename)
+        end
+      end
+
+    end # Matchers
+  end # Test
+end # SalebotUploader

data/lib/salebot_uploader/uploader/cache.rb

@@ -0,0 +1,223 @@
+require 'securerandom'
+
+module SalebotUploader
+
+  class FormNotMultipart < UploadError
+    def message
+      "You tried to assign a String or a Pathname to an uploader, for security reasons, this is not allowed.\n\n If this is a file upload, please check that your upload form is multipart encoded."
+    end
+  end
+
+  class CacheCounter
+    @@counter = 0
+
+    def self.increment
+      @@counter += 1
+    end
+  end
+
+  ##
+  # Generates a unique cache id for use in the caching system
+  #
+  # === Returns
+  #
+  # [String] a cache id in the format TIMEINT-PID-COUNTER-RND
+  #
+  def self.generate_cache_id
+    [
+      Time.now.utc.to_i,
+      SecureRandom.random_number(1_000_000_000_000_000),
+      '%04d' % (SalebotUploader::CacheCounter.increment % 10_000),
+      '%04d' % SecureRandom.random_number(10_000)
+    ].map(&:to_s).join('-')
+  end
+
+  module Uploader
+    module Cache
+      extend ActiveSupport::Concern
+
+      include SalebotUploader::Uploader::Callbacks
+      include SalebotUploader::Uploader::Configuration
+
+      included do
+        prepend Module.new {
+          def initialize(*)
+            super
+            @staged = false
+          end
+        }
+        attr_accessor :staged
+      end
+
+      module ClassMethods
+
+        ##
+        # Removes cached files which are older than one day. You could call this method
+        # from a rake task to clean out old cached files.
+        #
+        # You can call this method directly on the module like this:
+        #
+        #   SalebotUploader.clean_cached_files!
+        #
+        # === Note
+        #
+        # This only works as long as you haven't done anything funky with your cache_dir.
+        # It's recommended that you keep cache files in one place only.
+        #
+        def clean_cached_files!(seconds=60*60*24)
+          (cache_storage || storage).new(new).clean_cache!(seconds)
+        end
+      end
+
+      ##
+      # Returns true if the uploader has been cached
+      #
+      # === Returns
+      #
+      # [Bool] whether the current file is cached
+      #
+      def cached?
+        !!@cache_id
+      end
+
+      ##
+      # Caches the remotely stored file
+      #
+      # This is useful when about to process images. Most processing solutions
+      # require the file to be stored on the local filesystem.
+      #
+      def cache_stored_file!
+        cache!
+      end
+
+      def sanitized_file
+        ActiveSupport::Deprecation.warn('#sanitized_file is deprecated, use #file instead.')
+        file
+      end
+
+      ##
+      # Returns a String which uniquely identifies the currently cached file for later retrieval
+      #
+      # === Returns
+      #
+      # [String] a cache name, in the format TIMEINT-PID-COUNTER-RND/filename.txt
+      #
+      def cache_name
+        File.join(cache_id, original_filename) if cache_id && original_filename
+      end
+
+      ##
+      # Caches the given file. Calls process! to trigger any process callbacks.
+      #
+      # By default, cache!() uses copy_to(), which operates by copying the file
+      # to the cache, then deleting the original file.  If move_to_cache() is
+      # overridden to return true, then cache!() uses move_to(), which simply
+      # moves the file to the cache.  Useful for large files.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      # === Raises
+      #
+      # [SalebotUploader::FormNotMultipart] if the assigned parameter is a string
+      #
+      def cache!(new_file = file)
+        new_file = SalebotUploader::SanitizedFile.new(new_file)
+        return if new_file.empty?
+
+        raise SalebotUploader::FormNotMultipart if new_file.is_path? && ensure_multipart_form
+
+        self.cache_id = SalebotUploader.generate_cache_id unless cache_id
+
+        @identifier = nil
+        @staged = true
+        @filename = new_file.filename
+        self.original_filename = new_file.filename
+
+        begin
+          # first, create a workfile on which we perform processings
+          if move_to_cache
+            @file = new_file.move_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          else
+            @file = new_file.copy_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          end
+
+          with_callbacks(:cache, @file) do
+            @file = cache_storage.cache!(@file)
+          end
+        ensure
+          FileUtils.rm_rf(workfile_path(''))
+        end
+      end
+
+      ##
+      # Retrieves the file with the given cache_name from the cache.
+      #
+      # === Parameters
+      #
+      # [cache_name (String)] uniquely identifies a cache file
+      #
+      # === Raises
+      #
+      # [SalebotUploader::InvalidParameter] if the cache_name is incorrectly formatted.
+      #
+      def retrieve_from_cache!(cache_name)
+        with_callbacks(:retrieve_from_cache, cache_name) do
+          self.cache_id, self.original_filename = cache_name.to_s.split('/', 2)
+          @staged = true
+          @filename = original_filename
+          @file = cache_storage.retrieve_from_cache!(full_original_filename)
+        end
+      end
+
+      ##
+      # Calculates the path where the cache file should be stored.
+      #
+      # === Parameters
+      #
+      # [for_file (String)] name of the file <optional>
+      #
+      # === Returns
+      #
+      # [String] the cache path
+      #
+      def cache_path(for_file=full_original_filename)
+        File.join(*[cache_dir, @cache_id, for_file].compact)
+      end
+
+    protected
+
+      attr_reader :cache_id
+
+    private
+
+      def workfile_path(for_file=original_filename)
+        File.join(SalebotUploader.tmp_path, @cache_id, version_name.to_s, for_file)
+      end
+
+      attr_reader :original_filename
+
+      def cache_id=(cache_id)
+        # Earlier version used 3 part cache_id. Thus we should allow for
+        # the cache_id to have both 3 part and 4 part formats.
+        raise SalebotUploader::InvalidParameter, "invalid cache id" unless cache_id =~ /\A(-)?[\d]+\-[\d]+(\-[\d]{4})?\-[\d]{4}\z/
+        @cache_id = cache_id
+      end
+
+      def original_filename=(filename)
+        raise SalebotUploader::InvalidParameter, "invalid filename" if filename =~ SalebotUploader::SanitizedFile.sanitize_regexp
+        @original_filename = filename
+      end
+
+      def cache_storage
+        @cache_storage ||= (self.class.cache_storage || self.class.storage).new(self)
+      end
+
+      # We can override the full_original_filename method in other modules
+      def full_original_filename
+        forcing_extension(original_filename)
+      end
+    end # Cache
+  end # Uploader
+end # SalebotUploader

data/lib/salebot_uploader/uploader/callbacks.rb

@@ -0,0 +1,33 @@
+module SalebotUploader
+  module Uploader
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_before_callbacks, :_after_callbacks,
+                        :instance_writer => false
+        self._before_callbacks = Hash.new []
+        self._after_callbacks = Hash.new []
+      end
+
+      def with_callbacks(kind, *args)
+        self.class._before_callbacks[kind].each { |c| send c, *args }
+        yield
+        self.class._after_callbacks[kind].each { |c| send c, *args }
+      end
+
+      module ClassMethods
+        def before(kind, callback)
+          self._before_callbacks = self._before_callbacks.
+            merge kind => _before_callbacks[kind] + [callback]
+        end
+
+        def after(kind, callback)
+          self._after_callbacks = self._after_callbacks.
+            merge kind => _after_callbacks[kind] + [callback]
+        end
+      end # ClassMethods
+
+    end # Callbacks
+  end # Uploader
+end # SalebotUploader