photo-cook 1.1.2 → 1.2.1

data/lib/photo-cook/resize/__api__.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    class << self
+      attr_accessor :cache_dir
+      attr_accessor :multiplier
+    end
+    self.cache_dir  = 'resize-cache'
+    self.multiplier = DevicePixelRatio::DEFAULT
+
+    class << self
+      # Performs photo resizing with ImageMagick:
+      #   perform_resize('/application/public/uploads/car.png', '/application/public/resized_car.png', 280, 280)
+      #
+      # Source file: /application/public/uploads/car.png
+      # Result file: /application/public/resized_car.png
+      #
+      # NOTE: This method will perform validation
+      # NOTE: This method knows anything about resize cache
+      def perform(source_path, store_path, w, h, mode)
+        w, h, mode  = parse_options(w, h, mode, multiplier: 1.0)
+        photo, msec = PhotoCook::Utils.measure do
+          resizer.resize(source_path, store_path, w, h, mode)
+        end
+        PhotoCook.notify('resize', photo, msec)
+        photo
+      end
+
+      # Builds URI which points to PhotoCook::Middleware:
+      #   uri('/uploads/car.png', 280, 280)
+      #     => /uploads/resize-cache/fit-280x280/car.png
+      #
+      # NOTE: This method will perform validation
+      def uri(uri, width, height, mode, options = {})
+        Assemble.assemble_resize_uri(uri, *parse_options(width, height, mode, options))
+      end
+
+      # Inverse of PhotoCook#resize (see ^):
+      #   strip('/uploads/resize-cache/fit-280x280/car.png')
+      #     => /uploads/car.png
+      #
+      # NOTE: This method will perform validation
+      def strip(uri, check = false)
+        # TODO Implement check
+        Assemble.disassemble_resize_uri(uri)
+      end
+
+      # TODO Change uri to source_path
+      def base64_uri(uri, width, height, mode, options = {})
+        w, h, m     = parse_options(width, height, mode, options)
+        command     = Command.assemble(w, h, m)
+        source_path = Assemble.assemble_source_path_from_normal_uri(PhotoCook.root_path, uri)
+        store_path  = Assemble.assemble_store_path(PhotoCook.root_path, source_path, command)
+        photo       = if File.readable?(store_path)
+          MagickPhoto.new(store_path)
+        else
+          Resize.perform(source_path, store_path, w, h, m)
+        end
+
+        "data:#{photo.mime_type};base64,#{Base64.strict_encode64(File.read(photo.path))}"
+      end
+
+      def base64_uri_from_source_path(source_path, store_path, width, height, mode, options = {})
+        w, h, m = parse_options(width, height, mode, options)
+        photo   = if File.readable?(store_path)
+          MagickPhoto.new(store_path)
+        else
+          Resize.perform(source_path, store_path, w, h, m)
+        end
+
+        "data:#{photo.mime_type};base64,#{Base64.strict_encode64(File.read(photo.path))}"
+      end
+
+      # TODO Think about it. This can be very cool feature of PhotoCook
+      if defined?(Rails)
+        def static_asset_uri(uri, *rest)
+          # If production assets are precompiled and placed into public so we can resize as usually
+          Rails.application.config.serve_static_files ? uri : uri(uri, *rest)
+        end
+      end
+
+      def parse_options(width, height, mode, options)
+        multiplier  = options.fetch(:multiplier, self.multiplier).to_f
+        mode        = Mode.parse!(mode)
+        width       = Pixels.round(Pixels.parse(width)  * multiplier)
+        height      = Pixels.round(Pixels.parse(height) * multiplier)
+        Pixels.check!(width)
+        Pixels.check!(height)
+        [width, height, mode]
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/assemble.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    module Assemble
+      class << self
+        # Returns URI which points to PhotoCook::Resize::Middleware
+        #
+        # Arguments:
+        #   source_uri  => /uploads/photos/1/car.png
+        #   width       => :auto
+        #   height      => 640
+        #   mode        => fit
+        #
+        # Returns /uploads/photos/1/resized/width=auto&height=640&mode=fit/car.png
+        #
+        # NOTE: This method performs no validation
+        # NOTE: This method is very hot
+        def assemble_resize_uri(source_uri, width, height, mode)
+          source_uri.split('/').insert(-2, PhotoCook::Resize.cache_dir, Command.assemble(width, height, mode)).join('/')
+        end
+
+        # Strips resize command from URI. Inverse of +assemble_resize_uri+
+        #
+        # Arguments:
+        #   resize_uri => /uploads/photos/1/resized/width=auto&height=640&mode=fit/car.png
+        #
+        # Returns /uploads/photos/1/car.png
+        #
+        # NOTE: This method performs no validation
+        def disassemble_resize_uri(resize_uri)
+          # Take URI:
+          # /uploads/photos/1/resized/width=auto&height=640&mode=fit/car.png
+          #
+          # Split by separator:
+          # ["", "uploads", "photos", "1", "resized", "width=auto&height=640&mode=fit", "car.png"]
+          #
+          sections = resize_uri.split('/')
+
+          # Delete PhotoCook directory:
+          # ["", "uploads", "photos", "1", "width=auto&height=640&mode=fit", "car.png"]
+          sections.delete_at(-3)
+
+          # Delete command string:
+          # ["", "uploads", "photos", "1", "car.png"]
+          sections.delete_at(-2)
+
+          sections.join('/')
+        end
+
+        # Path where source photo is stored
+        #
+        # Arguments:
+        #   root       => /application
+        #   resize_uri => /uploads/photos/1/resized/width=auto&height=640&mode=fit/car.png
+        #
+        # Returns /application/public/uploads/photos/1/car.png
+        #
+        # NOTE: This method performs no validation
+        def assemble_source_path_from_resize_uri(root, resize_uri)
+          assemble_source_path_from_normal_uri(root, disassemble_resize_uri(resize_uri))
+        end
+
+        def assemble_source_path_from_normal_uri(root, normal_uri)
+          File.join(assemble_public_path(root), normal_uri)
+        end
+
+        # Path where resized photo is stored
+        #
+        # Arguments:
+        #   root              => /application
+        #   source_path       => /application/public/uploads/photos/1/car.png
+        #   assembled_command => width=auto&height=640&mode=fit
+        #
+        # Returns /application/public/resized/uploads/photos/1/width=auto&height=640&mode=fit/car.png
+        #
+        # NOTE: This method performs no validation
+        def assemble_store_path(root, source_path, assembled_command)
+          public         = assemble_public_path(root)
+          photo_location = dirname_or_blank(source_path.split(public).last)
+          File.join(public, PhotoCook::Resize.cache_dir, photo_location, assembled_command, File.basename(source_path))
+        end
+
+        # Path to public directory
+        #
+        # Arguments:
+        #   root => /application
+        #
+        # Returns /application/public
+        #
+        # NOTE: This method performs no validation
+        def assemble_public_path(root)
+          File.join(root, PhotoCook.public_dir)
+        end
+
+        def resize_uri?(uri)
+          sections = uri.split('/')
+
+          # Check if PhotoCook cache directory exists:
+          #   sections[-3] => resized
+          sections[-3] == PhotoCook::Resize.cache_dir &&
+
+          # Check if valid resize command exists:
+          #   sections[-2] => width=auto&height=640&mode=fit
+          matches_regex?(sections[-2], Command.regex)
+        end
+
+      private
+        def dirname_or_blank(path)
+          File.dirname(path).sub(/\A\.\z/, '')
+        end
+
+        # Ruby 2.4 Regexp#match?
+        if Regexp.instance_methods.include?(:match?)
+          def matches_regex?(string, regex)
+            regex.match?(string)
+          end
+        else
+          def matches_regex?(string, regex)
+            regex === string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/calculations.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    module Calculations
+      class << self
+        def size_to_fit(maxw, maxh, reqw, reqh, round = true)
+          outw, outh = maxw, maxh
+
+          scale = outw > reqw ? reqw / convert(outw) : 1.0
+          outw, outh = outw * scale, outh * scale
+
+          scale = outh > reqh ? reqh / convert(outh) : 1.0
+          outw, outh = outw * scale, outh * scale
+
+          round ? [round(outw), round(outh)] : [outw, outh]
+        end
+
+        def size_to_fill(maxw, maxh, reqw, reqh, round = true)
+          outw, outh = reqw, reqh
+
+          if reqw > maxw && reqh > maxh
+            if maxw >= maxh
+              outw = (reqw * maxh) / reqh.to_f
+              outh = maxh
+
+              if outw > maxw
+                outh = (outh * maxw) / convert(outw)
+                outw = maxw
+              end
+            else
+              outw = maxw
+              outh = (maxw * reqh) / reqw
+
+              if outh > maxh
+                outw = (outw * maxh) / convert(outh)
+                outh = maxh
+              end
+            end
+
+          elsif reqw > maxw
+            outw = maxw
+            outh = (reqh * maxw) / convert(reqw)
+
+          elsif reqh > maxh
+            outw = (reqw * maxh) / convert(reqh)
+            outh = maxh
+          end
+
+          round ? [round(outw), round(outh)] : [outw, outh]
+        end
+
+        def round(x)
+          PhotoCook::Pixels.round(x)
+        end
+
+      private
+        def convert(x)
+          x.kind_of?(Float) ? x : x.to_f
+        end
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/carrierwave.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    module CarrierWave
+      def resize(w, h, mode = :fit, options = {})
+        PhotoCook::Resize.uri(url, w, h, mode, options)
+      end
+
+      def resize_to_fit(w, h, options = {})
+        PhotoCook::Resize.uri(url, w, h, :fit, options)
+      end
+
+      def resize_to_fill(w, h, options = {})
+        PhotoCook::Resize.uri(url, w, h, :fill, options)
+      end
+
+      def resize_inline(w, h, mode = :fit, options = {})
+        PhotoCook::Resize.base64_uri(url, w, h, mode, options)
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    module Command
+      class << self
+        # Proportional support
+        # http://stackoverflow.com/questions/7200909/imagemagick-convert-to-fixed-width-proportional-height
+        #
+        # Device pixel ratio collection
+        # http://dpi.lv/
+        # http://www.canbike.org/CSSpixels/
+        def regex
+          @regex ||= /\A(?<mode>fit|fill)-(?<width>\d+)x(?<height>\d+)\z/
+        end
+
+        # NOTE: This method performs no validation
+        # NOTE: This method is very hot
+        def assemble(width, height, mode)
+          "#{mode}-#{width}x#{height}"
+        end
+
+        def extract(resize_uri)
+          resize_uri.split('/')[-2].match(@regex)
+        end
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/logging.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+PhotoCook.subscribe 'resize:middleware:match' do |uri|
+  PhotoCook.log do
+    log "PhotoCook::Resize::Middleware matched request for photo resize"
+    log "Request URI: #{uri}"
+  end
+end
+
+PhotoCook.subscribe 'resize' do |photo, msec|
+  PhotoCook.log do
+    log "Performed resize"
+    log "Source path:             #{photo.source_path}"
+    log "Store path:              #{photo.store_path}"
+    log "Max width:               #{photo.max_width}px"
+    log "Max height:              #{photo.max_height}px"
+    log "Desired width:           #{photo.desired_width}px"
+    log "Desired height:          #{photo.desired_height}px"
+    log "Desired aspect ratio:    #{photo.desired_aspect_ratio.round(3)}"
+    log "Calculated width:        #{photo.calculated_width}px"
+    log "Calculated height:       #{photo.calculated_height}px"
+    log "Calculated aspect ratio: #{photo.calculated_aspect_ratio.round(3)}"
+    log "Resize mode:             #{photo.resize_mode}"
+    log "Completed in:            #{msec.round(1)}ms"
+  end
+end

data/lib/photo-cook/resize/magick-photo.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    class MagickPhoto < MiniMagick::Image
+      attr_accessor :source_path
+      attr_accessor :store_path
+
+      attr_accessor :desired_width
+      attr_accessor :desired_height
+
+      attr_accessor :calculated_width
+      attr_accessor :calculated_height
+
+      attr_accessor :resize_mode
+
+      attr_reader :max_width
+      attr_reader :max_height
+
+      def initialize(*)
+        super
+        @max_width  = self[:width]
+        @max_height = self[:height]
+      end
+
+      def desired_aspect_ratio
+        desired_width / desired_height.to_f
+      end
+
+      def calculated_aspect_ratio
+        calculated_width / calculated_height.to_f
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/middleware.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    class Middleware
+      class << self
+        attr_accessor :headers
+      end
+
+      self.headers = { 'Cache-Control' => 'public, max-age=31536000, no-transform' }
+
+      def initialize(app)
+        @app = app
+      end
+
+      # Consider we have car.png in /uploads/photos/1/car.png
+      # We want to resize it with the following params:
+      #   Width:       choose automatically
+      #   Height:      exactly 640px
+      #   Mode:        fill
+      #
+      # Middleware will handle this URI:
+      #   /uploads/photos/1/resized/width=auto&height=640&mode=fill/car.png
+      #
+      def call(env)
+        uri = extract_uri(env)
+
+        # Check if URI contains PhotoCook resize indicators
+        return default_action(env) unless Assemble.resize_uri?(uri)
+
+        # If resized photo exists but nginx or apache didn't handle this request
+        return respond_with_file(env) if requested_file_exists?(uri)
+
+        # At this point we are sure that this request is targeting to resize photo
+        PhotoCook.notify('resize:middleware:match', uri)
+
+        # Matched data: width=auto&height=640&mode=fill
+        command = Command.extract(uri)
+
+        # Assemble path of the source photo:
+        #   => /application/public/uploads/photos/1/car.png
+        source_path = Assemble.assemble_source_path_from_resize_uri(root_path, uri)
+
+        # Assemble path of the resized photo:
+        #   => /application/public/resized/uploads/photos/1/COMMAND/car.png
+        store_path = Assemble.assemble_store_path(root_path, source_path, command.to_s)
+
+        if File.file?(store_path) && File.readable?(store_path)
+          symlink_cache_dir(source_path, store_path)
+          respond_with_file(env)
+
+        elsif File.file?(source_path) && File.readable?(source_path)
+          # Finally resize photo
+          # Resized photo will appear in resize directory
+          Resize.perform(source_path, store_path, command[:width], command[:height], command[:mode])
+          symlink_cache_dir(source_path, store_path)
+          respond_with_file(env)
+
+        else
+          default_action(env)
+        end
+      end
+
+    protected
+      def root_path
+        PhotoCook.root_path
+      end
+
+      def public_path
+        PhotoCook::Resize::Assemble.assemble_public_path(root_path)
+      end
+
+      def requested_file_exists?(uri)
+        # Check if file exists:
+        #   /application/public/uploads/photos/1/resized/width=auto&height=640&mode=fill/car.png
+        path = File.join(public_path, uri)
+        File.file?(path) && File.readable?(path)
+      end
+
+      def extract_uri(env)
+        Rack::Utils.clean_path_info(Rack::Utils.unescape(env['PATH_INFO']))
+      end
+
+      def default_action(env)
+        @app.call(env)
+      end
+
+      def respond_with_file(env)
+        # http://rubylogs.com/writing-rails-middleware/
+        # https://viget.com/extend/refactoring-patterns-the-rails-middleware-response-handler
+        status, headers, body = Rack::File.new(public_path).call(env)
+
+        # Rack::File will set Last-Modified, Content-Type and Content-Length
+        # We will set Cache-Control. This is default behaviour.
+        # This is configurable in PhotoCook::Resize::Middleware.headers
+        headers.merge!(self.class.headers) if status == 200 || status == 304
+
+        response = Rack::Response.new(body, status, headers)
+        response.finish
+      end
+
+      def symlink_cache_dir(source_path, store_path)
+        PhotoCook::Utils.make_relative_symlink(
+            File.dirname(File.dirname(store_path)),
+            File.join(File.dirname(source_path), PhotoCook::Resize.cache_dir))
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/mode.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    module Mode
+      class << self
+        def parse(mode)
+          case mode
+            when true          then :fill
+            when false         then :fit
+            when :fit, :fill   then mode
+            when 'fit', 'fill' then mode.to_sym
+          end
+        end
+
+        def parse!(mode)
+          check!(mode = parse(mode))
+          mode
+        end
+
+        def check!(mode)
+          case mode
+            when :fill, :fit then true
+            else raise Unknown, mode
+          end
+          true
+        end
+      end
+
+      class Unknown < ::ArgumentError
+        def initialize(mode)
+          super "Mode #{mode} is unknown"
+        end
+      end
+    end
+  end
+end

data/lib/photo-cook/resize/resizer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module PhotoCook
+  module Resize
+    class << self
+      def resizer
+        Resizer.instance
+      end
+    end
+
+    class Resizer
+      include Singleton
+
+      CENTER_GRAVITY          = 'Center'.freeze
+      TRANSPARENT_BACKGROUND  = 'rgba(255, 255, 255, 0.0)'.freeze
+
+      def resize(source_path, store_path, w, h, mode)
+        send("resize_to_#{mode}", source_path, store_path, w, h)
+      end
+
+      # Resize the photo to fit within the specified dimensions:
+      # - the original aspect ratio will be kept
+      # - new dimensions will be not larger then the specified
+      def resize_to_fit(source_path, store_path, width, height)
+        process photo: source_path, store: store_path do |photo|
+          outw, outh = Calculations.size_to_fit(*photo[:dimensions], width, height)
+          photo.resize "#{PhotoCook::Pixels.to_magick_dimensions(outw, outh)}>"
+
+          photo.resize_mode       = :fit
+          photo.desired_width     = width
+          photo.desired_height    = height
+          photo.calculated_width  = outw
+          photo.calculated_height = outh
+        end
+      end
+
+      # Resize the photo to fill within the specified dimensions:
+      # - the original aspect ratio will be kept
+      # - new dimensions may vary
+      def resize_to_fill(source_path, store_path, width, height)
+        process photo: source_path, store: store_path do |photo|
+          outw, outh = Calculations.size_to_fill(*photo[:dimensions], width, height)
+
+          photo.combine_options do |cmd|
+            cmd.resize     PhotoCook::Pixels.to_magick_dimensions(outw, outh) + '^'
+            cmd.gravity    CENTER_GRAVITY
+            cmd.background TRANSPARENT_BACKGROUND
+            cmd.crop       PhotoCook::Pixels.to_magick_dimensions(outw, outh)  + '+0+0'
+            cmd.repage.+
+          end
+
+          photo.resize_mode       = :fill
+          photo.desired_width     = width
+          photo.desired_height    = height
+          photo.calculated_width  = outw
+          photo.calculated_height = outh
+        end
+      end
+
+    protected
+
+      def process(photo:, store:)
+        photo = open(photo)
+        yield(photo)
+        store(photo, store)
+      end
+
+      def open(source_path)
+        # MiniMagick::Image.open creates a temporary file for us and protects original
+        photo = MagickPhoto.open(source_path)
+        photo.validate!
+        photo.source_path = source_path
+        photo
+      end
+
+      def store(resized_photo, store_path)
+        path_to_dir = File.dirname(store_path)
+
+        # Solution to broken symlinks.
+        # This added here because mkdir -p can't detect broken symlinks.
+        FileUtils.rm(path_to_dir) if !Dir.exists?(path_to_dir) && File.symlink?(path_to_dir)
+        FileUtils.mkdir_p(path_to_dir)
+        resized_photo.write(store_path)
+        resized_photo.store_path = store_path
+        resized_photo
+      end
+    end
+  end
+end