imgproxy 1.2.0 → 2.0.0

data/lib/imgproxy/builder.rb

@@ -3,6 +3,7 @@ require "base64"
 require "erb"
 
 require "imgproxy/options"
+require "imgproxy/options_aliases"
 
 module Imgproxy
   # Builds imgproxy URL
@@ -17,19 +18,15 @@ module Imgproxy
   #   builder.url_for("http://images.example.com/images/image1.jpg")
   #   builder.url_for("http://images.example.com/images/image2.jpg")
   class Builder
-    OMITTED_OPTIONS = %i[format].freeze
     # @param [Hash] options Processing options
     # @see Imgproxy.url_for
     def initialize(options = {})
       options = options.dup
 
-      @base64_encode_url = options.delete(:base64_encode_url)
-      @use_short_options = options.delete(:use_short_options)
-
-      @use_short_options = config.use_short_options if @use_short_options.nil?
-      @base64_encode_url = config.base64_encode_urls if @base64_encode_url.nil?
+      extract_builder_options(options)
 
       @options = Imgproxy::Options.new(options)
+      @format = @options.delete(:format)
     end
 
     # Genrates imgproxy URL
@@ -39,77 +36,68 @@ module Imgproxy
     #   the configured URL adapters
     # @see Imgproxy.url_for
     def url_for(image)
-      path = [*processing_options, url(image)].join("/")
+      path = [*processing_options, url(image, ext: @format)].join("/")
       signature = sign_path(path)
 
       File.join(Imgproxy.config.endpoint.to_s, signature, path)
     end
 
-    private
+    # Genrates imgproxy info URL
+    #
+    # @return [String] imgproxy info URL
+    # @param [String,URI, Object] image Source image URL or object applicable for
+    #   the configured URL adapters
+    # @see Imgproxy.info_url_for
+    def info_url_for(image)
+      path = url(image)
+      signature = sign_path(path)
 
-    OPTIONS_ALIASES = {
-      resize: :rs,
-      size: :s,
-      resizing_type: :rt,
-      width: :w,
-      height: :h,
-      enlarge: :en,
-      extend: :ex,
-      gravity: :g,
-      crop: :c,
-      padding: :pd,
-      trim: :t,
-      quality: :q,
-      max_bytes: :mb,
-      background: :bg,
-      adjust: :a,
-      brightness: :br,
-      contrast: :co,
-      saturation: :sa,
-      blur: :bl,
-      sharpen: :sh,
-      pixelate: :pix,
-      watermark: :wm,
-      watermark_url: :wmu,
-      preset: :pr,
-      cachebuster: :cb,
-    }.freeze
+      File.join(Imgproxy.config.endpoint.to_s, "info", signature, path)
+    end
+
+    private
 
     NEED_ESCAPE_RE = /[@?% ]|[^\p{Ascii}]/.freeze
 
+    def extract_builder_options(options)
+      @use_short_options = not_nil_or(options.delete(:use_short_options), config.use_short_options)
+      @base64_encode_url = not_nil_or(options.delete(:base64_encode_url), config.base64_encode_urls)
+      @escape_plain_url =
+        not_nil_or(options.delete(:escape_plain_url), config.always_escape_plain_urls)
+    end
+
     def processing_options
-      @processing_options ||=
-        @options.reject { |k, _| OMITTED_OPTIONS.include?(k) }.map do |key, value|
-          "#{option_alias(key)}:#{wrap_array(value).join(':')}"
-        end
+      @processing_options ||= @options.map do |key, value|
+        [option_alias(key), value].join(":")
+      end
     end
 
-    def plain_url_for(url)
-      escaped_url = url.match?(NEED_ESCAPE_RE) ? ERB::Util.url_encode(url) : url
+    def url(image, ext: nil)
+      url = config.url_adapters.url_of(image)
 
-      @options[:format] ? "plain/#{escaped_url}@#{@options[:format]}" : "plain/#{escaped_url}"
+      @base64_encode_url ? base64_url_for(url, ext: ext) : plain_url_for(url, ext: ext)
     end
 
-    def base64_url_for(url)
-      encoded_url = Base64.urlsafe_encode64(url).tr("=", "").scan(/.{1,16}/).join("/")
+    def plain_url_for(url, ext: nil)
+      escaped_url = need_escape_url?(url) ? ERB::Util.url_encode(url) : url
 
-      @options[:format] ? "#{encoded_url}.#{@options[:format]}" : encoded_url
+      ext ? "plain/#{escaped_url}@#{ext}" : "plain/#{escaped_url}"
     end
 
-    def option_alias(name)
-      return name unless config.use_short_options
+    def base64_url_for(url, ext: nil)
+      encoded_url = Base64.urlsafe_encode64(url).tr("=", "").scan(/.{1,16}/).join("/")
 
-      OPTIONS_ALIASES.fetch(name, name)
+      ext ? "#{encoded_url}.#{ext}" : encoded_url
     end
 
-    def wrap_array(value)
-      value.is_a?(Array) ? value : [value]
+    def need_escape_url?(url)
+      @escape_plain_url || url.match?(NEED_ESCAPE_RE)
     end
 
-    def url(image)
-      url = config.url_adapters.url_of(image)
+    def option_alias(name)
+      return name unless @use_short_options
 
-      @base64_encode_url ? base64_url_for(url) : plain_url_for(url)
+      Imgproxy::OPTIONS_ALIASES.fetch(name, name)
     end
 
     def sign_path(path)
@@ -130,11 +118,11 @@ module Imgproxy
     end
 
     def signature_key
-      config.key
+      config.raw_key
     end
 
     def signature_salt
-      config.salt
+      config.raw_salt
     end
 
     def signature_size
@@ -144,5 +132,9 @@ module Imgproxy
     def config
       Imgproxy.config
     end
+
+    def not_nil_or(value, fallback)
+      value.nil? ? fallback : value
+    end
   end
 end

data/lib/imgproxy/config.rb

@@ -1,44 +1,110 @@
+require "anyway_config"
+
 require "imgproxy/url_adapters"
 
 module Imgproxy
   # Imgproxy config
+  #
+  # @!attribute endpoint
+  #   imgproxy endpoint
+  #   @return [String]
+  # @!attribute key
+  #   imgproxy hex-encoded signature key
+  #   @return [String]
+  # @!attribute salt
+  #   imgproxy hex-encoded signature salt
+  #   @return [String]
+  # @!attribute raw_key
+  #   Decoded signature key
+  #   @return [String]
+  # @!attribute raw_salt
+  #   Decoded signature salt
+  #   @return [String]
+  # @!attribute signature_size
+  #   imgproxy signature size. Defaults to 32
+  #   @return [String]
+  # @!attribute use_short_options
+  #   Use short processing option names (+rs+ for +resize+, +g+ for +gravity+, etc).
+  #   Defaults to true
+  #   @return [String]
+  # @!attribute base64_encode_urls
+  #   Base64 encode the URL. Defaults to false
+  #   @return [String]
+  # @!attribute always_escape_plain_urls
+  #   Always escape plain URLs. Defaults to false
+  #   @return [String]
+  # @!attribute use_s3_urls
+  #   Use short S3 urls (s3://...) when possible. Defaults to false
+  #   @return [String]
+  # @!attribute use_gcs_urls
+  #   Use short Google Cloud Storage urls (gs://...) when possible. Defaults to false
+  #   @return [String]
+  # @!attribute gcs_bucket
+  #   Google Cloud Storage bucket name
+  #   @return [String]
+  # @!attribute shrine_host
+  #   Shrine host
+  #   @return [String]
+  #
   # @see Imgproxy.configure
-  class Config
-    # @return [String] imgproxy endpoint
-    attr_accessor :endpoint
-    # @return [String] imgproxy signature key
-    attr_accessor :key
-    # @return [String] imgproxy signature salt
-    attr_accessor :salt
-    # @return [Integer] imgproxy signature size. Defaults to 32
-    attr_accessor :signature_size
-    # @return [Boolean] use short processing option names
-    #   (`rs` for `resize`, `g` for `gravity`, etc).
-    #   Defaults to true
-    attr_accessor :use_short_options
-
-    # @return [Boolean] base64 encode the URL
-    #   Defaults to false
-    attr_accessor :base64_encode_urls
-
-    def initialize
-      self.signature_size = 32
-      self.use_short_options = true
-      self.base64_encode_urls = false
+  # @see https://github.com/palkan/anyway_config anyway_config
+  class Config < Anyway::Config
+    attr_config(
+      :endpoint,
+      :key,
+      :salt,
+      :raw_key,
+      :raw_salt,
+      signature_size: 32,
+      use_short_options: true,
+      base64_encode_urls: false,
+      always_escape_plain_urls: false,
+      use_s3_urls: false,
+      use_gcs_urls: false,
+      gcs_bucket: nil,
+      shrine_host: nil,
+    )
+
+    alias_method :set_key, :key=
+    alias_method :set_raw_key, :raw_key=
+    alias_method :set_salt, :salt=
+    alias_method :set_raw_salt, :raw_salt=
+    private :set_key, :set_raw_key, :set_salt, :set_raw_salt
+
+    def key=(value)
+      value = value&.to_s
+      super(value)
+      set_raw_key(value && [value].pack("H*"))
     end
 
-    # Decodes hex-encoded key and sets it to {#key}
-    #
-    # @param value [String] hex-encoded signature key
+    def raw_key=(value)
+      value = value&.to_s
+      super(value)
+      set_key(value&.unpack("H*")&.first)
+    end
+
+    def salt=(value)
+      value = value&.to_s
+      super(value)
+      set_raw_salt(value && [value].pack("H*"))
+    end
+
+    def raw_salt=(value)
+      value = value&.to_s
+      super(value)
+      set_salt(value&.unpack("H*")&.first)
+    end
+
+    # @deprecated Please use {#key} instead
     def hex_key=(value)
-      self.key = value.nil? ? nil : [value].pack("H*")
+      warn "[DEPRECATION] #hex_key is deprecated. Please use #key instead."
+      self.key = value
     end
 
-    # Decodes hex-encoded salt and sets it to {#salt}
-    #
-    # @param value [String] hex-encoded signature salt
+    # @deprecated Please use {#salt} instead
     def hex_salt=(value)
-      self.salt = value.nil? ? nil : [value].pack("H*")
+      warn "[DEPRECATION] #hex_salt is deprecated. Please use #salt instead."
+      self.salt = value
     end
 
     # URL adapters config. Allows to use this gem with ActiveStorage, Shrine, etc.

data/lib/imgproxy/extensions/active_storage.rb

@@ -12,6 +12,16 @@ module Imgproxy
         return options.url_for(self) if options.is_a?(Imgproxy::Builder)
         Imgproxy.url_for(self, options)
       end
+
+      # Returns imgproxy info URL for an attachment
+      #
+      # @return [String]
+      # @param options [Hash, Imgproxy::Builder]
+      # @see Imgproxy.info_url_for
+      def imgproxy_info_url(options = {})
+        return options.info_url_for(self) if options.is_a?(Imgproxy::Builder)
+        Imgproxy.info_url_for(self, options)
+      end
     end
   end
 end

data/lib/imgproxy/extensions/shrine.rb

@@ -12,6 +12,16 @@ module Imgproxy
         return options.url_for(self) if options.is_a?(Imgproxy::Builder)
         Imgproxy.url_for(self, options)
       end
+
+      # Returns imgproxy info URL for a Shrine::UploadedFile instance
+      #
+      # @return [String]
+      # @param options [Hash, Imgproxy::Builder]
+      # @see Imgproxy.info_url_for
+      def imgproxy_info_url(options = {})
+        return options.info_url_for(self) if options.is_a?(Imgproxy::Builder)
+        Imgproxy.info_url_for(self, options)
+      end
     end
   end
 end

data/lib/imgproxy/options.rb

@@ -1,153 +1,115 @@
+require "imgproxy/trim_array"
+require "imgproxy/options_casters/string"
+require "imgproxy/options_casters/integer"
+require "imgproxy/options_casters/float"
+require "imgproxy/options_casters/bool"
+require "imgproxy/options_casters/array"
+require "imgproxy/options_casters/base64"
+require "imgproxy/options_casters/resize"
+require "imgproxy/options_casters/size"
+require "imgproxy/options_casters/extend"
+require "imgproxy/options_casters/gravity"
+require "imgproxy/options_casters/crop"
+require "imgproxy/options_casters/trim"
+require "imgproxy/options_casters/adjust"
+require "imgproxy/options_casters/watermark"
+require "imgproxy/options_casters/jpeg_options"
+require "imgproxy/options_casters/png_options"
+require "imgproxy/options_casters/gif_options"
+
 module Imgproxy
   # Formats and regroups processing options
   class Options < Hash
-    STRING_OPTS = %i[resizing_type extend_gravity gravity crop_gravity trim_color watermark_position
-                     watermark_url style cachebuster format base64_encode_url].freeze
-    INT_OPTS = %i[width height crop_width crop_height trim_threshold quality brightness pixelate
-                  watermark_x_offset watermark_y_offset max_bytes].freeze
-    FLOAT_OPTS = %i[dpr extend_gravity_x extend_gravity_y gravity_x gravity_y crop_gravity_x
-                    crop_gravity_y contrast saturation blur sharpen watermark_opacity
-                    watermark_scale].freeze
-    BOOL_OPTS = %i[enlarge extend trim_equal_hor trim_equal_ver].freeze
-    ARRAY_OPTS = %i[padding background preset].freeze
-    ALL_OPTS = (STRING_OPTS + INT_OPTS + FLOAT_OPTS + BOOL_OPTS + ARRAY_OPTS).freeze
-
-    OPTS_PRIORITY = %i[ resize size resizing_type width height dpr enlarge extend gravity
-                        crop padding trim quality max_bytes background adjust brightness contrast
-                        saturation blur sharpen pixelate watermark watermark_url style preset
-                        cachebuster ].freeze
+    using TrimArray
+
+    CASTERS = {
+      resize:                 Imgproxy::OptionsCasters::Resize,
+      size:                   Imgproxy::OptionsCasters::Size,
+      resizing_type:          Imgproxy::OptionsCasters::String,
+      resizing_algorithm:     Imgproxy::OptionsCasters::String,
+      width:                  Imgproxy::OptionsCasters::Integer,
+      height:                 Imgproxy::OptionsCasters::Integer,
+      dpr:                    Imgproxy::OptionsCasters::Float,
+      enlarge:                Imgproxy::OptionsCasters::Bool,
+      extend:                 Imgproxy::OptionsCasters::Extend,
+      gravity:                Imgproxy::OptionsCasters::Gravity,
+      crop:                   Imgproxy::OptionsCasters::Crop,
+      padding:                Imgproxy::OptionsCasters::Array,
+      trim:                   Imgproxy::OptionsCasters::Trim,
+      rotate:                 Imgproxy::OptionsCasters::Integer,
+      quality:                Imgproxy::OptionsCasters::Integer,
+      max_bytes:              Imgproxy::OptionsCasters::Integer,
+      background:             Imgproxy::OptionsCasters::Array,
+      background_alpha:       Imgproxy::OptionsCasters::Float,
+      adjust:                 Imgproxy::OptionsCasters::Adjust,
+      brightness:             Imgproxy::OptionsCasters::Integer,
+      contrast:               Imgproxy::OptionsCasters::Float,
+      saturation:             Imgproxy::OptionsCasters::Float,
+      blur:                   Imgproxy::OptionsCasters::Float,
+      sharpen:                Imgproxy::OptionsCasters::Float,
+      pixelate:               Imgproxy::OptionsCasters::Integer,
+      unsharpening:           Imgproxy::OptionsCasters::String,
+      watermark:              Imgproxy::OptionsCasters::Watermark,
+      watermark_url:          Imgproxy::OptionsCasters::Base64,
+      style:                  Imgproxy::OptionsCasters::Base64,
+      jpeg_options:           Imgproxy::OptionsCasters::JpegOptions,
+      png_options:            Imgproxy::OptionsCasters::PngOptions,
+      gif_options:            Imgproxy::OptionsCasters::GifOptions,
+      page:                   Imgproxy::OptionsCasters::Integer,
+      video_thumbnail_second: Imgproxy::OptionsCasters::Integer,
+      preset:                 Imgproxy::OptionsCasters::Array,
+      cachebuster:            Imgproxy::OptionsCasters::String,
+      strip_metadata:         Imgproxy::OptionsCasters::Bool,
+      strip_color_profile:    Imgproxy::OptionsCasters::Bool,
+      auto_rotate:            Imgproxy::OptionsCasters::Bool,
+      filename:               Imgproxy::OptionsCasters::String,
+      format:                 Imgproxy::OptionsCasters::String,
+    }.freeze
+
+    META = %i[size resize adjust].freeze
 
     # @param options [Hash] raw processing options
     def initialize(options)
-      merge!(options.slice(*ALL_OPTS))
-
-      typecast
-
-      group_options
-
-      encode_style
-      encode_watermark_url
-
-      replace(Hash[sort_by { |k, _| OPTS_PRIORITY.index(k) || 99 }])
-
-      freeze
-    end
-
-    private
+      # Options order hack: initialize known and meta options with nil value to preserve order
+      CASTERS.each_key { |n| self[n] = nil if options.key?(n) || META.include?(n) }
 
-    def typecast
-      compact.each do |key, value|
-        self[key] =
-          case key
-          when *STRING_OPTS then value.to_s
-          when *INT_OPTS then value.to_i
-          when *FLOAT_OPTS then value.to_f
-          when *BOOL_OPTS then bool(value)
-          when *ARRAY_OPTS then wrap_array(value)
-          end
+      options.each do |name, value|
+        caster = CASTERS[name]
+        self[name] = caster ? caster.cast(value) : unwrap_hash(value)
       end
-    end
-
-    def bool(value)
-      value && value != 0 && value != "0" ? 1 : 0
-    end
-
-    def wrap_array(value)
-      value.is_a?(Array) ? value : [value]
-    end
 
-    def group_options
-      group_crop_opts
-      group_extend_opts
       group_resizing_opts
-      group_gravity_opts
       group_adjust_opts
-      group_watermark_opts
-      group_trim_opts
-    end
 
-    def group_crop_opts
-      crop_width = delete(:crop_width)
-      crop_height = delete(:crop_height)
-      crop_gravity = extract_and_trim_nils(:crop_gravity, :crop_gravity_x, :crop_gravity_y)
+      compact!
+    end
 
-      return unless crop_width || crop_height
+    private
 
-      crop_gravity = nil if crop_gravity[0].nil?
+    def unwrap_hash(raw)
+      return raw unless raw.is_a?(Hash)
 
-      self[:crop] = [crop_width || 0, crop_height || 0, *crop_gravity]
+      raw.flat_map do |_key, val|
+        unwrap_hash(val)
+      end
     end
 
     def group_resizing_opts
-      return unless self[:width] && self[:height]
+      return unless self[:width] && self[:height] && !self[:size] && !self[:resize]
 
       self[:size] = extract_and_trim_nils(:width, :height, :enlarge, :extend)
-
       self[:resize] = [delete(:resizing_type), *delete(:size)] if self[:resizing_type]
     end
 
-    def group_gravity_opts
-      gravity = extract_and_trim_nils(:gravity, :gravity_x, :gravity_y)
-
-      self[:gravity] = gravity unless gravity[0].nil?
-    end
-
-    def group_extend_opts
-      extend_opts =
-        extract_and_trim_nils(:extend, :extend_gravity, :extend_gravity_x, :extend_gravity_y)
-
-      return if extend_opts[0].nil?
-      return self[:extend] = 0 if extend_opts[0].zero?
-
-      self[:extend] = extend_opts
-    end
-
     def group_adjust_opts
-      return unless values_at(:brightness, :contrast, :saturation).count { |o| !o.nil? } > 1
+      return if self[:adjust]
+      return unless values_at(:brightness, :contrast, :saturation).count { |o| o } > 1
 
       self[:adjust] = extract_and_trim_nils(:brightness, :contrast, :saturation)
     end
 
-    def group_watermark_opts
-      watermark = extract_and_trim_nils(
-        :watermark_opacity,
-        :watermark_position,
-        :watermark_x_offset,
-        :watermark_y_offset,
-        :watermark_scale,
-      )
-
-      self[:watermark] = watermark unless watermark[0].nil?
-    end
-
-    def group_trim_opts
-      trim = extract_and_trim_nils(
-        :trim_threshold,
-        :trim_color,
-        :trim_equal_hor,
-        :trim_equal_ver,
-      )
-
-      self[:trim] = trim unless trim[0].nil?
-    end
-
-    def encode_style
-      return if self[:style].nil?
-      self[:style] = Base64.urlsafe_encode64(self[:style]).tr("=", "")
-    end
-
-    def encode_watermark_url
-      return if self[:watermark_url].nil?
-      self[:watermark_url] = Base64.urlsafe_encode64(self[:watermark_url]).tr("=", "")
-    end
-
     def extract_and_trim_nils(*keys)
-      trim_nils(keys.map { |k| delete(k) })
-    end
-
-    def trim_nils(value)
-      value.delete_at(-1) while !value.empty? && value[-1].nil?
-      value
+      keys.map { |k| delete(k) }.trim!
     end
   end
 end