imgproxy 1.0.6 → 2.0.1

data/lib/imgproxy/config.rb

@@ -1,39 +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
-
-    def initialize
-      self.signature_size = 32
-      self.use_short_options = true
+  # @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,100 +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 gravity watermark_position style cachebuster format].freeze
-    INT_OPTS = %i[width height quality watermark_x_offset watermark_y_offset].freeze
-    FLOAT_OPTS = %i[dpr gravity_x gravity_y blur sharpen watermark_opacity watermark_scale].freeze
-    BOOL_OPTS = %i[enlarge extend].freeze
-    ARRAY_OPTS = %i[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 quality
-                        background blur sharpen watermark 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))
+      # 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) }
 
-      typecast
+      options.each do |name, value|
+        caster = CASTERS[name]
+        self[name] = caster ? caster.cast(value) : unwrap_hash(value)
+      end
 
       group_resizing_opts
-      group_gravity_opts
-      group_watermark_opts
-
-      encode_style
+      group_adjust_opts
 
-      replace(Hash[sort_by { |k, _| OPTS_PRIORITY.index(k) || 99 }])
-
-      freeze
+      compact!
     end
 
     private
 
-    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
-      end
-    end
-
-    def bool(value)
-      value && value != 0 && value != "0" ? 1 : 0
-    end
+    def unwrap_hash(raw)
+      return raw unless raw.is_a?(Hash)
 
-    def wrap_array(value)
-      value.is_a?(Array) ? value : [value]
+      raw.flat_map do |_key, val|
+        unwrap_hash(val)
+      end
     end
 
     def group_resizing_opts
-      return unless self[:width] && self[:height]
-
-      self[:size] = trim_nils(
-        [delete(:width), delete(:height), delete(:enlarge), delete(:extend)],
-      )
+      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 = trim_nils(
-        [
-          delete(:gravity),
-          delete(:gravity_x),
-          delete(:gravity_y),
-        ],
-      )
-
-      self[:gravity] = gravity unless gravity[0].nil?
-    end
-
-    def group_watermark_opts
-      watermark = trim_nils(
-        [
-          delete(:watermark_opacity),
-          delete(:watermark_position),
-          delete(:watermark_x_offset),
-          delete(:watermark_y_offset),
-          delete(:watermark_scale),
-        ],
-      )
-
-      self[:watermark] = watermark unless watermark[0].nil?
-    end
+    def group_adjust_opts
+      return if self[:adjust]
+      return unless values_at(:brightness, :contrast, :saturation).count { |o| o } > 1
 
-    def encode_style
-      return if self[:style].nil?
-      self[:style] = Base64.urlsafe_encode64(self[:style]).tr("=", "")
+      self[:adjust] = extract_and_trim_nils(:brightness, :contrast, :saturation)
     end
 
-    def trim_nils(value)
-      value.delete_at(-1) while !value.empty? && value[-1].nil?
-      value
+    def extract_and_trim_nils(*keys)
+      keys.map { |k| delete(k) }.trim!
     end
   end
 end

data/lib/imgproxy/options_aliases.rb

@@ -0,0 +1,43 @@
+module Imgproxy
+  OPTIONS_ALIASES = {
+    resize: :rs,
+    size: :s,
+    resizing_type: :rt,
+    resizing_algorithm: :ra,
+    width: :w,
+    height: :h,
+    enlarge: :el,
+    extend: :ex,
+    gravity: :g,
+    crop: :c,
+    padding: :pd,
+    trim: :t,
+    rotate: :rot,
+    quality: :q,
+    max_bytes: :mb,
+    background: :bg,
+    background_alpha: :bga,
+    adjust: :a,
+    brightness: :br,
+    contrast: :co,
+    saturation: :sa,
+    blur: :bl,
+    sharpen: :sh,
+    pixelate: :pix,
+    unsharpening: :ush,
+    watermark: :wm,
+    watermark_url: :wmu,
+    style: :st,
+    jpeg_options: :jpego,
+    png_options: :pngo,
+    gif_options: :gifo,
+    page: :pg,
+    video_thumbnail_second: :vts,
+    preset: :pr,
+    cachebuster: :cb,
+    strip_metadata: :sm,
+    strip_color_profile: :scp,
+    auto_rotate: :ar,
+    filename: :fn,
+  }.freeze
+end

data/lib/imgproxy/options_casters/adjust.rb

@@ -0,0 +1,22 @@
+require "imgproxy/options_casters/group"
+require "imgproxy/options_casters/integer"
+require "imgproxy/options_casters/float"
+
+module Imgproxy
+  module OptionsCasters
+    # Casts gravity option
+    module Adjust
+      CASTER = Imgproxy::OptionsCasters::Group.new(
+        brightness: Imgproxy::OptionsCasters::Integer,
+        contrast: Imgproxy::OptionsCasters::Float,
+        saturation: Imgproxy::OptionsCasters::Float,
+      ).freeze
+
+      def self.cast(raw)
+        return raw unless raw.is_a?(Hash)
+
+        CASTER.cast(raw)
+      end
+    end
+  end
+end

data/lib/imgproxy/options_casters/array.rb

@@ -0,0 +1,12 @@
+module Imgproxy
+  module OptionsCasters
+    # Casts array option
+    module Array
+      def self.cast(raw)
+        return if raw.nil?
+
+        raw.is_a?(Array) ? raw : [raw]
+      end
+    end
+  end
+end

data/lib/imgproxy/options_casters/base64.rb

@@ -0,0 +1,12 @@
+require "base64"
+
+module Imgproxy
+  module OptionsCasters
+    # Casts string option to base64
+    module Base64
+      def self.cast(raw)
+        ::Base64.urlsafe_encode64(raw.to_s).tr("=", "") unless raw.nil?
+      end
+    end
+  end
+end