rack_resize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 89ff24cb927e939e377fa9de0e4af8d736e026d2536a5721a94c8884c745de16
+  data.tar.gz: 13e4ca927f5ef1f058a528ded9158cd324e2eaf0e34c2797b21e1791028a31fc
+SHA512:
+  metadata.gz: 58f951cd5354359a5a6261a739ded0e7136d346a91572c4bc8ba856530feb57644b1825959acc4ecdc79f91a15ab93e1e38c58d3578d82bd4c803a70ac015fdc
+  data.tar.gz: 462e57a07904d0e4c845b40611a2d7bc601e4c2fb207b8b7f2cccac9de934d6471bc222550e770ba19e0e58235d977d86b4ed8df0771761ac4b09a884495f106

data/.gitignore

@@ -0,0 +1,3 @@
+.idea/
+Gemfile.lock
+.DS_Store

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'mini_magick'
+gem 'ruby-vips'
+gem 'rszr'

data/README.md

@@ -0,0 +1,6 @@
+
+RESIZE IMAGE mini_magick samples/big.jpg - {:width=>"150"} - 0.949s
+RESIZE IMAGE sips samples/big.jpg - {:width=>"150"} - 0.121s
+RESIZE IMAGE vips samples/big.jpg - {:width=>"150"} - 0.116s
+
+s.add_runtime_dependency "image_processing", ["> 1.0", "< 3.0"]

data/config.ru

@@ -0,0 +1,10 @@
+require_relative "lib/rack_resize"
+require "rack/static"
+
+use RackResize::RackApp, processor: :imlib2, assets_folder: "samples" # save_resized: false,
+
+use Rack::Static, urls: [""], root: "samples", index: "index.html"
+
+run lambda { |env|
+  [200, {'Content-Type' => 'text/html'}, ['Hello from Rack!']]
+}

data/lib/rack_resize/configuration.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+
+class RackResize::Configuration
+  PROCESSORS = %i[sips vips mini_magick imlib2].freeze
+
+  attr_reader :processor
+  attr_accessor :save_resized, :default_quality, :cache_folder, :assets_folder
+
+  alias_method :save_resized?, :save_resized
+
+  def initialize(options = {})
+    @processor       = options[:processor] || RUBY_PLATFORM.include?('darwin') ? :sips : :mini_magick
+    @save_resized    = options.key?(:save_resized) ? options[:save_resized] : true
+    @default_quality = options[:default_quality] || 95
+    @cache_folder    = options[:cache_folder]
+    @assets_folder   = options[:assets_folder] ? Pathname.new(options[:assets_folder]) : nil
+
+    if defined?(Rails)
+      @cache_folder ||= Rails.root.join('tmp', 'rack_resize_cache')
+      @assets_folder ||= Rails.root.join('app', 'assets', 'images')
+    end
+
+    if options[:processor]
+      self.processor = options[:processor]
+    end
+  end
+
+  def processor=(value)
+    value = value.to_sym
+    unless PROCESSORS.include?(value)
+      raise ArgumentError, "Unknown processor #{value.inspect}. Must be one of: #{PROCESSORS.join(', ')}"
+    end
+    @processor = value
+    @processor_instance = nil
+  end
+
+  def processor_instance
+    @processor_instance ||= case @processor
+                            when :mini_magick then RackResize::MiniMagick.new
+                            when :vips        then RackResize::Processors::Vips.new
+                            when :sips        then RackResize::Processors::Sips.new
+                            when :imlib2      then RackResize::Processors::Imlib2.new
+                            else
+                              raise "RackResize - Unknow image processor #{@processor.inspect}"
+                            end
+  end
+end

data/lib/rack_resize/input_parsers/cloudflare.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Cloudflare
+end

data/lib/rack_resize/processing.rb

@@ -0,0 +1,49 @@
+class RackResize::Processing
+  attr_reader :config
+
+  def initialize(config:)
+    @config = config
+  end
+
+  def process!(source_file:, req_params:)
+    if config.save_resized?
+      tmp_file_name = config.cache_folder.join(Digest::MD5.hexdigest(source_file.to_s) + File.extname(source_file))
+      FileUtils.mkdir_p(tmp_file_name.dirname)
+
+      unless tmp_file_name.exist?
+        process_file(req_params:, source_file:, target_file: tmp_file_name.to_s)
+      end
+
+      logger.info("Serving cached file #{tmp_file_name}")
+      return StringIO.new(File.open(tmp_file_name.to_s, "rb", &:read))
+    else
+      file_content = process_file(req_params:, source_file:, target_file: nil)
+      return StringIO.new(file_content)
+    end
+  end
+
+  def process_file(source_file:, req_params:, target_file: nil)
+    dpr = req_params[:dpr]&.to_f || 1.0
+    target_width = (req_params[:w]&.to_i || req_params[:width]&.to_i)&.*(dpr)
+    target_height = (req_params[:h]&.to_i || req_params[:height]&.to_i)&.*(dpr)
+
+    start_time = Time.now
+    begin
+      return config.processor_instance.resize(source_file:, target_file:, target_width:, target_height:)
+    ensure
+      processing_time = (Time.now.to_f - start_time.to_f).round(3)
+      logger.info("RESIZE IMAGE #{config.processor} #{source_file} - #{req_params} - #{processing_time}s")
+    end
+  end
+
+  def logger
+    @logger ||= begin
+                  if defined?(Rails) && Rails.logger
+                    Rails.logger
+                  else
+                    require 'logger'
+                    Logger.new(STDOUT)
+                  end
+                end
+  end
+end

data/lib/rack_resize/processors/imlib2.rb

@@ -0,0 +1,20 @@
+begin
+  require "rszr"
+rescue LoadError
+  raise LoadError, "RackResize::Processors::Imlib2 requires the rszr gem. Please add `gem \"rszr\"` to your Gemfile."
+end
+
+class RackResize::Processors::Imlib2
+
+  def resize(source_file:, target_file:, target_width:, target_height:)
+    image = Rszr::Image.load(source_file)
+    image.resize!(target_width || :auto, target_height || :auto) if target_width || target_height
+
+    if target_file
+      image.call(destination: target_file)
+      image.save(target_file)
+    else
+      image.save_data(format: source_file.to_s =~ /\.png$/ ? :png : :jpeg)
+    end
+  end
+end

data/lib/rack_resize/processors/mini_magick.rb

@@ -0,0 +1,53 @@
+begin
+  require "image_processing"
+rescue LoadError
+  raise LoadError, "RackResize::Processors::MiniMagick requires the image_processing gem. Please add `gem \"image_processing\"` to your Gemfile."
+end
+
+# require 'mini_magick'
+# MiniMagick.logger.level = :debug
+
+class RackResize::Processors::MiniMagick
+
+  def resize(source_file:, target_width:, target_height:, target_file: nil)
+    image = ImageProcessing::MiniMagick.source(source_file)
+    image = image.resize_to_limit(target_width, target_height) if target_width || target_height
+    image = image.saver(quality: RackResize.config.default_quality)
+
+    if target_file
+      image.call(destination: target_file)
+    else
+      begin
+        tmp_file = image.call
+        return tmp_file.read
+      ensure
+        tmp_file.unlink
+      end
+    end
+  end
+
+  def resize_mm(source_file:, target_width:, target_height:, target_file: nil)
+    image = MiniMagick::Image.open(source_file)
+    image.combine_options do |img|
+      img.resize("#{target_width}x#{target_height}>") if target_width || target_height
+      img.quality(RackResize.config.default_quality)
+
+      if target_file
+        img.write(target_file)
+      end
+    end
+
+    unless target_file
+      return File.open(image.path, 'rb', &:read)
+    end
+
+  ensure
+    image&.destroy!
+  end
+end
+
+# magick /Users/pavel/Work/resume-io/app/assets/images/templates/vancouver.jpg -auto-orient -resize 426.0x> -quality 95 /Users/pavel/Work/resume-io/tmp/cdn_cgi_cache/60f2727cce350874040b321219f05766.jpg
+
+
+# magick mogrify -resize 426.0x> /var/folders/n9/b__lxh7j1_xcwg4k_8j2_39m0000gp/T/mini_magick20260709-58478-qowydk.jpg
+# magick mogrify -quality 95 /var/folders/n9/b__lxh7j1_xcwg4k_8j2_39m0000gp/T/mini_magick20260709-58478-qowydk.jpg

data/lib/rack_resize/processors/sips.rb

@@ -0,0 +1,37 @@
+require "shellwords"
+
+class RackResize::Processors::Sips
+
+  def resize(source_file:, target_width:, target_height:, target_file: nil)
+    # args = ["sips", "--deleteColorManagementProperties", "--optimizeColorForSharing"]
+    args = ["sips", "--deleteColorManagementProperties", "--debug"]
+    args += ["-s formatOptions", RackResize.config.default_quality]
+    args << "--resampleWidth" << target_width.to_i if target_width
+    args << "--resampleHeight" << target_height.to_i if target_height
+
+    if target_file
+      args << "-o" << Shellwords.escape(target_file)
+    else
+      tmp_file = Tempfile.new(["result", File.extname(source_file)])
+      args << "-o" << tmp_file.path
+    end
+
+    args << Shellwords.escape(source_file)
+
+    pp [:args, args, args.join(" ")]
+
+    result = `#{args.join(" ")}`
+
+    puts "sips command result: #{result}"
+
+    unless target_file
+      begin
+        return File.open(tmp_file.path, 'rb', &:read)
+      ensure
+        tmp_file.unlink
+      end
+    end
+
+    nil
+  end
+end

data/lib/rack_resize/processors/vips.rb

@@ -0,0 +1,27 @@
+begin
+  require "image_processing"
+rescue LoadError
+  raise LoadError, "RackResize::Processors::Vips requires the image_processing gem. Please add `gem \"image_processing\"` to your Gemfile."
+end
+
+class RackResize::Processors::Vips
+
+  def resize(source_file:, target_file:, target_width:, target_height:)
+    image = ImageProcessing::Vips.source(source_file)
+    image = image.resize_to_limit(target_width, target_height) if target_width || target_height
+    image = image.saver(quality: RackResize.config.default_quality)
+
+    # image.call(destination: target_file)
+
+    if target_file
+      image.call(destination: target_file)
+    else
+      begin
+        tmp_file = image.call
+        return tmp_file.read
+      ensure
+        tmp_file.unlink
+      end
+    end
+  end
+end

data/lib/rack_resize/rack_app.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+class RackResize::RackApp
+
+  attr_reader :config
+
+  def initialize(*args, **options)
+    if args.first
+      @app = args.first
+    end
+
+    @config = options == {} ? RackResize.config : RackResize::Configuration.new(options)
+    @processing = RackResize::Processing.new(config: @config)
+    @path_prefix = options[:path_prefix] || "/cdn-cgi/image"
+  end
+
+  def call(env)
+    # process string like this
+    # /cdn-cgi/image/width=426,format=auto/assets/templates/vancouver-27c47f55.jpg
+
+    request = Rack::Request.new(env)
+    fullpath = request.path_info
+
+    unless fullpath.start_with?(@path_prefix)
+      return @app.call(env)
+    end
+
+    fullpath = fullpath.delete_prefix("/cdn-cgi").delete_prefix("/image").delete_prefix("/")
+    file_path_match = fullpath.match(%r{(?<params>[^\/]+)(?<file>\/.+?)(-[\da-f]{8})?(?<ext>\.\w{2,})$})
+
+    return error_resp("can't parse file path") unless file_path_match
+
+    req_params = file_path_match[:params].split(",").map {|s| s.split("=") }.to_h.transform_keys(&:to_sym)
+    asset_path = "#{file_path_match[:file]}#{file_path_match[:ext]}"
+
+    if defined?(Rails)
+      asset_path = asset_path.delete_prefix("/assets/")
+    else
+      asset_path = asset_path.delete_prefix("/#{config.assets_folder}/")
+    end
+
+    asset_file = config.assets_folder.join(asset_path.sub(%r{^/assets/}, ''))
+
+    return error_resp(".. is not allowed in image path") if asset_path.include?("..")
+
+    return error_resp("invalid file path") unless asset_file.to_s.start_with?(config.assets_folder.to_s)
+    return error_resp("file not exists on a server") unless asset_file.exist?
+
+    file_content = @processing.process!(source_file: asset_file, req_params:)
+    return send_file(asset_file:, file_content:)
+  end
+
+  def error_resp(message, http_code: 404)
+    [http_code, {}, [message]]
+  end
+
+  def send_file(asset_file:, file_content: nil)
+    content_type = Rack::Mime.mime_type(File.extname(asset_file), "application/octet-stream")
+    # file = file_path ? File.open(file_path, "rb") : StringIO.new(file_content)
+
+    [
+      200,
+      {
+        "content-type"        => content_type,
+        "content-length"      => file_content.size.to_s,
+        "content-disposition" => "inline",
+        "cache-control"       => "max-age=86400" # 1 day
+      },
+      file_content
+    ]
+  end
+end

data/lib/rack_resize/rails_autoload.rb

@@ -0,0 +1,10 @@
+require "rack_resize"
+require "rails"
+
+module MyGem
+  class Railtie < Rails::Railtie
+    initializer "rack_resize.auto_register_itself" do |app|
+      app.config.middleware.insert_before 0, RackResize::RackApp
+    end
+  end
+end

data/lib/rack_resize.rb

@@ -0,0 +1,27 @@
+module RackResize
+  autoload :Configuration, "#{__dir__}/rack_resize/configuration"
+  autoload :RackApp,       "#{__dir__}/rack_resize/rack_app"
+  autoload :Processing,    "#{__dir__}/rack_resize/processing"
+  # autoload :ImageController,    "#{__dir__}/rack_resize/image_controller"
+
+  module Processors
+    autoload :Sips,      "#{__dir__}/rack_resize/processors/sips"
+    autoload :Vips,      "#{__dir__}/rack_resize/processors/vips"
+    autoload :MiniMagic, "#{__dir__}/rack_resize/processors/mini_magic"
+    autoload :Imlib2,    "#{__dir__}/rack_resize/processors/imlib2"
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def config
+      configuration
+    end
+
+    def configure
+      yield configuration
+    end
+  end
+end

data/rack_resize.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = "rack_resize"
+  s.version     = "0.1.0"
+  s.author      = ["Pavel Evstigneev"]
+  s.email       = ["pavel.evst@gmail.com"]
+  s.homepage    = "https://github.com/paxa/rack_resize"
+  s.summary     = %q{Image resizing on a fly}
+  s.license     = 'MIT'
+  s.required_ruby_version = ['>= 3.0']
+
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = []
+
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "rack", ["> 2.0", "< 4.0"]
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: rack_resize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pavel Evstigneev
+bindir: bin
+cert_chain: []
+date: 2026-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+email:
+- pavel.evst@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- config.ru
+- lib/rack_resize.rb
+- lib/rack_resize/configuration.rb
+- lib/rack_resize/input_parsers/cloudflare.rb
+- lib/rack_resize/processing.rb
+- lib/rack_resize/processors/imlib2.rb
+- lib/rack_resize/processors/mini_magick.rb
+- lib/rack_resize/processors/sips.rb
+- lib/rack_resize/processors/vips.rb
+- lib/rack_resize/rack_app.rb
+- lib/rack_resize/rails_autoload.rb
+- rack_resize.gemspec
+homepage: https://github.com/paxa/rack_resize
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Image resizing on a fly
+test_files: []