imgwire 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 465414c80dd7d88016d6e156b188ed81c5c074836000087e4e47d11baed5a8ae
-  data.tar.gz: 8de6fcd2da02b947376eb73d9021eeb35bb62109133acecee8ad8f361c992ab8
+  metadata.gz: 51b2aefb2be738f37e07af70399bd781d56bdeacc886b4fdd86335ac2c52539f
+  data.tar.gz: e60ce39c3b7825ab9cbcb632073839c5343cd667b3dbd6c5f3f6c6b25b522b44
 SHA512:
-  metadata.gz: 6ee90396ef5802259a36e17740a2c5b7e7e103b029b3f7eae3bb5966d613dc1a546a00ba2cfe1c0ea564bcab0e43938d7643be9387727a6d2b296d194a26a209
-  data.tar.gz: 169a27d84d24340b998692974e8d4ec9f1c8248def2c14d0bcee3475cebc7e321c4cff6f8583090dd2eaabf90dd7160e6ea0c2c16024b586eecf0bad0316e9bd
+  metadata.gz: 51e0d57435f845cf12f0b3b677e75ab32fae572d1c2ee5b347c35cee54f964bdae11d9a974dd1f210fa3b09cedc9057332afb77e2ee01cef62a0a60c6d11547d
+  data.tar.gz: 18bc491397f7fd0f0433abd0e9d645327ebd5437fe8365ac80eaf699f9c741a6403dd28a11b1731c6b408889eb6a157f7da20d83f3810c8dce10c379530fc720

data/CODEGEN_VERSION

@@ -1 +1 @@
-213554905f77b6ffb7a29c020c632196bf0d7567b10d10f40a0a59839008d248
+b57e439d6e9c3859c7bddb889658b5ff808503ccc136ea28a56e0fd57a1678aa

data/README.md

@@ -1,6 +1,9 @@
+![imgwire.dev Logo](https://cdn.imgwire.dev/6b024480-a5ac-426d-b539-2e4fccc4c6ac/26f80c13-48bd-4bb9-866e-5e9392b11a6a/4ba5fe50-433b-40db-a847-938d2081c21a?w=280&quality=80)
+
 # `imgwire`
 
 [![RubyGems version](https://img.shields.io/gem/v/imgwire.svg)](https://rubygems.org/gems/imgwire)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![CI](https://github.com/Blackhawk-Software/imgwire-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/Blackhawk-Software/imgwire-ruby/actions/workflows/ci.yml)
 [![Release](https://github.com/Blackhawk-Software/imgwire-ruby/actions/workflows/release.yml/badge.svg)](https://github.com/Blackhawk-Software/imgwire-ruby/actions/workflows/release.yml)
 
@@ -8,6 +11,9 @@
 
 Use it in Rails apps, workers, jobs, and other backend runtimes to authenticate with a Server API Key, upload files from Ruby IO objects, manage server-side resources, and generate image transformation URLs without rebuilding imgwire request plumbing yourself.
 
+> [!TIP]
+> Obtain an API key by signing up at [imgwire.dev](https://imgwire.dev). Read the full API & SDK documentation [here](https://docs.imgwire.dev/guides/backend-quickstart).
+
 ## Installation
 
 ```bash
@@ -114,6 +120,30 @@ puts image.url(
 )
 ```
 
+The helper accepts the transform names and aliases from
+`docs/imgwire-url-transformations-guide.md`. Multi-field transforms can be
+passed as their URL string syntax or as Ruby hashes:
+
+```ruby
+puts image.url(
+  gradient: {
+    colors: ["#0b1f5e", "#ff2a2a"],
+    angle: 90,
+    opacity: 0.25,
+    blend: "overlay"
+  },
+  watermark_url: "https://example.com/logo.png",
+  watermark_position: {
+    gravity: "southeast",
+    x: -24,
+    y: -24,
+    opacity: 0.85
+  }
+)
+```
+
+Out-of-range transform values are omitted from the generated URL.
+
 ## Generation
 
 From a clean checkout:

data/generated/lib/imgwire-generated/models/image_schema.rb

@@ -15,6 +15,8 @@ require 'time'
 
 module ImgwireGenerated
   class ImageSchema
+    attr_accessor :can_upload
+
     attr_accessor :cdn_url
 
     attr_accessor :created_at
@@ -37,6 +39,8 @@ module ImgwireGenerated
 
     attr_accessor :idempotency_key
 
+    attr_accessor :is_directly_deliverable
+
     attr_accessor :mime_type
 
     attr_accessor :original_filename
@@ -80,6 +84,7 @@ module ImgwireGenerated
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
+        :'can_upload' => :'can_upload',
         :'cdn_url' => :'cdn_url',
         :'created_at' => :'created_at',
         :'custom_metadata' => :'custom_metadata',
@@ -91,6 +96,7 @@ module ImgwireGenerated
         :'height' => :'height',
         :'id' => :'id',
         :'idempotency_key' => :'idempotency_key',
+        :'is_directly_deliverable' => :'is_directly_deliverable',
         :'mime_type' => :'mime_type',
         :'original_filename' => :'original_filename',
         :'processed_metadata_at' => :'processed_metadata_at',
@@ -116,6 +122,7 @@ module ImgwireGenerated
     # Attribute type mapping.
     def self.openapi_types
       {
+        :'can_upload' => :'Boolean',
         :'cdn_url' => :'String',
         :'created_at' => :'Time',
         :'custom_metadata' => :'Hash<String, CustomMetadataValue>',
@@ -127,6 +134,7 @@ module ImgwireGenerated
         :'height' => :'Integer',
         :'id' => :'String',
         :'idempotency_key' => :'String',
+        :'is_directly_deliverable' => :'Boolean',
         :'mime_type' => :'SupportedMimeType',
         :'original_filename' => :'String',
         :'processed_metadata_at' => :'Time',
@@ -168,6 +176,12 @@ module ImgwireGenerated
         h[k.to_sym] = v
       }
 
+      if attributes.key?(:'can_upload')
+        self.can_upload = attributes[:'can_upload']
+      else
+        self.can_upload = nil
+      end
+
       if attributes.key?(:'cdn_url')
         self.cdn_url = attributes[:'cdn_url']
       else
@@ -238,6 +252,12 @@ module ImgwireGenerated
         self.idempotency_key = nil
       end
 
+      if attributes.key?(:'is_directly_deliverable')
+        self.is_directly_deliverable = attributes[:'is_directly_deliverable']
+      else
+        self.is_directly_deliverable = nil
+      end
+
       if attributes.key?(:'mime_type')
         self.mime_type = attributes[:'mime_type']
       else
@@ -298,6 +318,10 @@ module ImgwireGenerated
     def list_invalid_properties
       warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
       invalid_properties = Array.new
+      if @can_upload.nil?
+        invalid_properties.push('invalid value for "can_upload", can_upload cannot be nil.')
+      end
+
       if @cdn_url.nil?
         invalid_properties.push('invalid value for "cdn_url", cdn_url cannot be nil.')
       end
@@ -326,6 +350,10 @@ module ImgwireGenerated
         invalid_properties.push('invalid value for "id", id cannot be nil.')
       end
 
+      if @is_directly_deliverable.nil?
+        invalid_properties.push('invalid value for "is_directly_deliverable", is_directly_deliverable cannot be nil.')
+      end
+
       if @mime_type.nil?
         invalid_properties.push('invalid value for "mime_type", mime_type cannot be nil.')
       end
@@ -357,6 +385,7 @@ module ImgwireGenerated
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @can_upload.nil?
       return false if @cdn_url.nil?
       return false if @created_at.nil?
       return false if @custom_metadata.nil?
@@ -364,6 +393,7 @@ module ImgwireGenerated
       return false if @extension.nil?
       return false if @height.nil?
       return false if @id.nil?
+      return false if @is_directly_deliverable.nil?
       return false if @mime_type.nil?
       return false if @original_filename.nil?
       return false if @size_bytes.nil?
@@ -373,6 +403,16 @@ module ImgwireGenerated
       true
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] can_upload Value to be assigned
+    def can_upload=(can_upload)
+      if can_upload.nil?
+        fail ArgumentError, 'can_upload cannot be nil'
+      end
+
+      @can_upload = can_upload
+    end
+
     # Custom attribute writer method with validation
     # @param [Object] cdn_url Value to be assigned
     def cdn_url=(cdn_url)
@@ -443,6 +483,16 @@ module ImgwireGenerated
       @id = id
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] is_directly_deliverable Value to be assigned
+    def is_directly_deliverable=(is_directly_deliverable)
+      if is_directly_deliverable.nil?
+        fail ArgumentError, 'is_directly_deliverable cannot be nil'
+      end
+
+      @is_directly_deliverable = is_directly_deliverable
+    end
+
     # Custom attribute writer method with validation
     # @param [Object] mime_type Value to be assigned
     def mime_type=(mime_type)
@@ -508,6 +558,7 @@ module ImgwireGenerated
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
+          can_upload == o.can_upload &&
           cdn_url == o.cdn_url &&
           created_at == o.created_at &&
           custom_metadata == o.custom_metadata &&
@@ -519,6 +570,7 @@ module ImgwireGenerated
           height == o.height &&
           id == o.id &&
           idempotency_key == o.idempotency_key &&
+          is_directly_deliverable == o.is_directly_deliverable &&
           mime_type == o.mime_type &&
           original_filename == o.original_filename &&
           processed_metadata_at == o.processed_metadata_at &&
@@ -539,7 +591,7 @@ module ImgwireGenerated
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [cdn_url, created_at, custom_metadata, deleted_at, environment_id, exif_data, extension, hash_sha256, height, id, idempotency_key, mime_type, original_filename, processed_metadata_at, purpose, size_bytes, status, updated_at, upload_token_id, width].hash
+      [can_upload, cdn_url, created_at, custom_metadata, deleted_at, environment_id, exif_data, extension, hash_sha256, height, id, idempotency_key, is_directly_deliverable, mime_type, original_filename, processed_metadata_at, purpose, size_bytes, status, updated_at, upload_token_id, width].hash
     end
 
     # Builds the object from hash

data/generated/lib/imgwire-generated/models/supported_mime_type.rb

@@ -16,13 +16,18 @@ require 'time'
 module ImgwireGenerated
   class SupportedMimeType
     IMAGE_JPEG = "image/jpeg".freeze
+    IMAGE_JXL = "image/jxl".freeze
     IMAGE_PNG = "image/png".freeze
     IMAGE_WEBP = "image/webp".freeze
     IMAGE_AVIF = "image/avif".freeze
     IMAGE_GIF = "image/gif".freeze
+    IMAGE_VND_MICROSOFT_ICON = "image/vnd.microsoft.icon".freeze
+    IMAGE_HEIC = "image/heic".freeze
+    IMAGE_BMP = "image/bmp".freeze
+    IMAGE_TIFF = "image/tiff".freeze
 
     def self.all_vars
-      @all_vars ||= [IMAGE_JPEG, IMAGE_PNG, IMAGE_WEBP, IMAGE_AVIF, IMAGE_GIF].freeze
+      @all_vars ||= [IMAGE_JPEG, IMAGE_JXL, IMAGE_PNG, IMAGE_WEBP, IMAGE_AVIF, IMAGE_GIF, IMAGE_VND_MICROSOFT_ICON, IMAGE_HEIC, IMAGE_BMP, IMAGE_TIFF].freeze
     end
 
     # Builds the enum from string

data/lib/imgwire/image.rb

@@ -1,25 +1,11 @@
 # frozen_string_literal: true
 
 require 'uri'
+require 'imgwire/url_transformations'
 
 module Imgwire
   class Image < ImgwireGenerated::ImageSchema
     PRESETS = %w[thumbnail small medium large].freeze
-    ROTATE_ANGLES = [0, 90, 180, 270, 360].freeze
-    FORMATS = %w[jpg png avif gif webp].freeze
-
-    RULES = {
-      'background' => %w[background bg],
-      'crop' => %w[crop],
-      'enlarge' => %w[enlarge],
-      'format' => %w[format fm],
-      'gravity' => %w[gravity],
-      'height' => %w[height h],
-      'quality' => %w[quality q],
-      'rotate' => %w[rotate rot],
-      'strip_metadata' => %w[strip_metadata strip],
-      'width' => %w[width w]
-    }.freeze
 
     def self.wrap(value)
       return value if value.is_a?(self)
@@ -38,7 +24,7 @@ module Imgwire
     def url(options = {})
       options = symbolize_keys(options)
       path = build_preset_path(options[:preset])
-      query = build_query(options.except(:preset))
+      query = Imgwire::URLTransformations.build_query(options.except(:preset))
 
       uri = URI.parse(cdn_url)
       uri.path = path
@@ -61,77 +47,7 @@ module Imgwire
       raise ArgumentError, 'Invalid transformation rule value for preset' unless PRESETS.include?(preset)
 
       uri = URI.parse(cdn_url)
-      slash_index = uri.path.rindex('/')
-      prefix = slash_index ? uri.path[0..slash_index] : ''
-      file_name = slash_index ? uri.path[(slash_index + 1)..] : uri.path
-      dot_index = file_name.rindex('.')
-      raise ArgumentError, 'Cannot apply a preset to a CDN URL without a file extension.' if dot_index.nil?
-
-      "#{prefix}#{file_name}@#{preset}"
-    end
-
-    def build_query(options)
-      present = []
-
-      RULES.each do |canonical, aliases|
-        matches = aliases.filter_map do |name|
-          symbol = name.to_sym
-          [symbol, options[symbol]] if options.key?(symbol)
-        end
-
-        next if matches.empty?
-        raise ArgumentError, "Duplicate transformation rule: #{canonical}" if matches.length > 1
-
-        value = normalize_rule(canonical, matches.first.last)
-        present << [canonical, value] unless value.nil?
-      end
-
-      present
-    end
-
-    def normalize_rule(canonical, value)
-      case canonical
-      when 'background'
-        string = value.to_s.delete_prefix('#')
-        unless string.match?(/\A[\da-fA-F]{6}\z/)
-          raise ArgumentError,
-                "Invalid transformation rule value for #{canonical}"
-        end
-
-        string.downcase
-      when 'crop', 'gravity'
-        value.to_s
-      when 'enlarge', 'strip_metadata'
-        value ? 'true' : nil
-      when 'format'
-        string = value.to_s
-        unless FORMATS.include?(string)
-          raise ArgumentError,
-                "Invalid transformation rule value for #{canonical}"
-        end
-
-        string
-      when 'height', 'quality', 'width'
-        integer = Integer(value)
-        unless integer.positive?
-          raise ArgumentError,
-                "Invalid transformation rule value for #{canonical}"
-        end
-
-        integer.to_s
-      when 'rotate'
-        integer = Integer(value)
-        unless ROTATE_ANGLES.include?(integer)
-          raise ArgumentError,
-                "Invalid transformation rule value for #{canonical}"
-        end
-
-        integer.to_s
-      else
-        raise ArgumentError, "Unsupported transformation rule: #{canonical}"
-      end
-    rescue ArgumentError, TypeError
-      raise ArgumentError, "Invalid transformation rule value for #{canonical}"
+      "#{uri.path}@#{preset}"
     end
   end
 end

data/lib/imgwire/url_transformations.rb

@@ -0,0 +1,907 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require 'uri'
+
+module Imgwire
+  # rubocop:disable Metrics/ModuleLength
+  module URLTransformations
+    RULES = {
+      'adjust' => %w[a adjust],
+      'background' => %w[bg background],
+      'background_alpha' => %w[bga background_alpha],
+      'blur' => %w[bl blur],
+      'brightness' => %w[br brightness],
+      'color_profile' => %w[cp icc color_profile],
+      'colorize' => %w[col colorize],
+      'contrast' => %w[co contrast],
+      'crop' => %w[c crop],
+      'dpi' => %w[dpi],
+      'dpr' => %w[dpr],
+      'duotone' => %w[dt duotone],
+      'enlarge' => %w[el enlarge],
+      'extend' => %w[ex extend],
+      'extend_aspect_ratio' => %w[exar extend_ar extend_aspect_ratio],
+      'flip' => %w[fl flip],
+      'format' => %w[f format ext extension fm],
+      'gradient' => %w[gr gradient],
+      'gravity' => %w[g gravity],
+      'height' => %w[h height],
+      'hue' => %w[hu hue],
+      'keep_copyright' => %w[kcr keep_copyright],
+      'lightness' => %w[l lightness],
+      'min-height' => %w[mh min_height min-height],
+      'min-width' => %w[mw min_width min-width],
+      'monochrome' => %w[mc monochrome],
+      'negate' => %w[neg negate],
+      'normalize' => %w[norm normalise normalize],
+      'padding' => %w[pd padding],
+      'pixelate' => %w[pix pixelate],
+      'quality' => %w[q quality],
+      'resizing_algorithm' => %w[ra resizing_algorithm],
+      'resizing_type' => %w[resizing_type],
+      'rotate' => %w[rot rotate],
+      'saturation' => %w[sa saturation],
+      'sharpen' => %w[sh sharpen],
+      'strip_color_profile' => %w[scp strip_color_profile],
+      'strip_metadata' => %w[sm strip_metadata strip],
+      'watermark' => %w[wm watermark],
+      'watermark_position' => %w[wmp watermark_offset watermark_position],
+      'watermark_rotate' => %w[wmr wm_rot watermark_rotate],
+      'watermark_shadow' => %w[wmsh watermark_shadow],
+      'watermark_size' => %w[wms watermark_size],
+      'watermark_text' => %w[wmt watermark_text],
+      'watermark_url' => %w[wmu watermark_url],
+      'width' => %w[w width],
+      'zoom' => %w[z zoom]
+    }.freeze
+
+    COLOR_PROFILES = %w[srgb rgb16 cmyk keep preserve].freeze
+    FORMATS = %w[auto jpg jpeg png webp avif gif tiff].freeze
+    FLIP_VALUES = %w[vertical horizontal both].freeze
+    RESIZING_ALGORITHMS = %w[nearest cubic mitchell lanczos2 lanczos3].freeze
+    RESIZING_TYPES = %w[cover contain fill inside outside].freeze
+    RESIZING_TYPE_ALIASES = {
+      'auto' => 'inside',
+      'fill-down' => 'inside',
+      'fit' => 'inside',
+      'force' => 'fill'
+    }.freeze
+    GRAVITY_VALUES = %w[
+      ce center north south east west northeast northwest southeast southwest attention entropy
+    ].freeze
+    GRAVITY_ALIASES = {
+      'n' => 'north',
+      'no' => 'north',
+      's' => 'south',
+      'so' => 'south',
+      'e' => 'east',
+      'ea' => 'east',
+      'w' => 'west',
+      'we' => 'west',
+      'ne' => 'northeast',
+      'noea' => 'northeast',
+      'se' => 'southeast',
+      'soea' => 'southeast',
+      'nw' => 'northwest',
+      'nowe' => 'northwest',
+      'sw' => 'southwest',
+      'sowe' => 'southwest',
+      'ce:sm' => 'attention'
+    }.freeze
+
+    module_function
+
+    def build_query(options)
+      normalized_options = normalize_top_level_keys(options)
+
+      RULES.each_with_object([]) do |(canonical, aliases), present|
+        matches = aliases.filter_map do |name|
+          key = name.to_sym
+          [key, normalized_options[key]] if normalized_options.key?(key)
+        end
+
+        next if matches.empty?
+        raise ArgumentError, "Duplicate transformation rule: #{canonical}" if matches.length > 1
+
+        value = normalize_rule(canonical, matches.first.last)
+        present << [canonical, value] unless value.nil?
+      end
+    end
+
+    def normalize_rule(canonical, value)
+      case canonical
+      when 'adjust'
+        normalize_adjust(value)
+      when 'background', 'colorize'
+        normalize_color(value)
+      when 'background_alpha'
+        normalize_number(value, min: 0, max: 1)
+      when 'blur'
+        normalize_true_or_number(value, min: 0.3, max: 100)
+      when 'brightness', 'lightness', 'saturation'
+        normalize_number(value, min: 0.01, max: 10)
+      when 'color_profile'
+        normalize_enum(value, COLOR_PROFILES)
+      when 'contrast'
+        normalize_contrast(value)
+      when 'crop'
+        normalize_crop(value)
+      when 'dpi'
+        normalize_integer(value, min: 1, max: 600)
+      when 'dpr'
+        normalize_number(value, min: 0.01, max: 8)
+      when 'duotone'
+        normalize_duotone(value)
+      when 'enlarge', 'keep_copyright', 'strip_color_profile', 'strip_metadata'
+        normalize_boolean_flag(value)
+      when 'extend'
+        normalize_extend(value)
+      when 'extend_aspect_ratio'
+        normalize_extend_aspect_ratio(value)
+      when 'flip'
+        normalize_flip(value)
+      when 'format'
+        normalize_enum(value, FORMATS)
+      when 'gradient'
+        normalize_gradient(value)
+      when 'gravity'
+        normalize_gravity(value)
+      when 'height', 'min-height', 'min-width', 'width'
+        normalize_integer(value, min: 1, max: 8192)
+      when 'hue'
+        normalize_number(value)
+      when 'monochrome'
+        normalize_monochrome(value)
+      when 'negate'
+        normalize_negate(value)
+      when 'normalize'
+        normalize_normalize(value)
+      when 'padding'
+        normalize_padding(value)
+      when 'pixelate'
+        normalize_integer(value, min: 2, max: 256)
+      when 'quality'
+        normalize_integer(value, min: 1, max: 100)
+      when 'resizing_algorithm'
+        normalize_enum(value, RESIZING_ALGORITHMS)
+      when 'resizing_type'
+        normalize_enum(value, RESIZING_TYPES, aliases: RESIZING_TYPE_ALIASES)
+      when 'rotate', 'watermark_rotate'
+        normalize_rotate(value)
+      when 'sharpen'
+        normalize_sharpen(value)
+      when 'watermark'
+        normalize_watermark(value)
+      when 'watermark_position'
+        normalize_watermark_position(value)
+      when 'watermark_shadow'
+        normalize_watermark_shadow(value)
+      when 'watermark_size'
+        normalize_watermark_size(value)
+      when 'watermark_text'
+        normalize_text_or_json_object(value)
+      when 'watermark_url'
+        normalize_watermark_url(value)
+      when 'zoom'
+        normalize_zoom(value)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def normalize_adjust(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      if hash
+        brightness = normalize_number(field(hash, 'brightness'))
+        saturation = normalize_number(field(hash, 'saturation'))
+        color = normalize_number(field(hash, 'color'))
+
+        return contiguous_segments([brightness], [saturation, color])
+      end
+
+      segments = split_segments(value, min: 1, max: 3)
+      return unless segments
+
+      brightness = normalize_number(segments[0])
+      saturation = normalize_number(segments[1]) if segments.length > 1
+      color = normalize_number(segments[2]) if segments.length > 2
+
+      contiguous_segments([brightness], [saturation, color].first(segments.length - 1))
+    end
+
+    def normalize_contrast(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      if hash
+        multiplier = normalize_number(field(hash, 'multiplier'))
+        pivot = normalize_number(field(hash, 'pivot'))
+
+        return contiguous_segments([multiplier], [pivot])
+      end
+
+      segments = split_segments(value, min: 1, max: 2)
+      return unless segments
+
+      multiplier = normalize_number(segments[0])
+      pivot = normalize_number(segments[1]) if segments.length > 1
+
+      contiguous_segments([multiplier], [pivot].first(segments.length - 1))
+    end
+
+    def normalize_crop(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_crop_hash(hash) if hash
+
+      segments = split_segments(value, min: 2, max: 5)
+      return unless [2, 3, 4, 5].include?(segments&.length)
+
+      if segments.length <= 3
+        width = normalize_integer(segments[0], min: 1)
+        height = normalize_integer(segments[1], min: 1)
+        gravity = normalize_gravity(segments[2]) if segments.length == 3
+
+        return contiguous_segments([width, height], [gravity].first(segments.length - 2))
+      end
+
+      x = normalize_integer(segments[0])
+      y = normalize_integer(segments[1])
+      width = normalize_integer(segments[2], min: 1)
+      height = normalize_integer(segments[3], min: 1)
+      gravity = normalize_gravity(segments[4]) if segments.length == 5
+
+      contiguous_segments([x, y, width, height], [gravity].first(segments.length - 4))
+    end
+
+    def normalize_crop_hash(hash)
+      x = normalize_integer(field(hash, 'x'))
+      y = normalize_integer(field(hash, 'y'))
+      width = normalize_integer(field(hash, 'width', 'w'), min: 1)
+      height = normalize_integer(field(hash, 'height', 'h'), min: 1)
+      gravity = normalize_gravity(field(hash, 'gravity', 'g'))
+
+      if field?(hash, 'x') || field?(hash, 'y')
+        contiguous_segments([x, y, width, height], [gravity])
+      else
+        contiguous_segments([width, height], [gravity])
+      end
+    end
+
+    def normalize_duotone(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      if hash
+        shadow = normalize_color(field(hash, 'shadowColor', 'shadow_color', 'shadow'))
+        highlight = normalize_color(field(hash, 'highlightColor', 'highlight_color', 'highlight'))
+
+        return contiguous_segments([shadow, highlight], [])
+      end
+
+      segments = split_segments(value, min: 2, max: 2)
+      return unless segments
+
+      shadow = normalize_color(segments[0])
+      highlight = normalize_color(segments[1])
+
+      contiguous_segments([shadow, highlight], [])
+    end
+
+    def normalize_extend(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_extend_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 5)
+      return unless segments
+
+      top = normalize_integer(segments[0])
+      right = normalize_integer(segments[1]) if segments.length > 1
+      bottom = normalize_integer(segments[2]) if segments.length > 2
+      left = normalize_integer(segments[3]) if segments.length > 3
+      background = normalize_color(segments[4]) if segments.length > 4
+
+      contiguous_segments([top], [right, bottom, left, background].first(segments.length - 1))
+    end
+
+    def normalize_extend_hash(hash)
+      top = normalize_integer(field(hash, 'top'))
+      right = normalize_integer(field(hash, 'right'))
+      bottom = normalize_integer(field(hash, 'bottom'))
+      left = normalize_integer(field(hash, 'left'))
+      background = normalize_color(field(hash, 'background', 'bg'))
+
+      compact_json = compact_json_object(
+        hash,
+        'top' => top,
+        'right' => right,
+        'bottom' => bottom,
+        'left' => left,
+        'background' => background
+      )
+      return unless compact_json
+
+      contiguous_segments([top], [right, bottom, left, background]) || compact_json
+    end
+
+    def normalize_extend_aspect_ratio(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      if hash
+        ratio = normalize_number(field(hash, 'ratio'), min: 0.000001)
+        return ratio if ratio
+
+        width = normalize_integer(field(hash, 'width', 'w'), min: 1)
+        height = normalize_integer(field(hash, 'height', 'h'), min: 1)
+
+        return contiguous_segments([width, height], [])
+      end
+
+      segments = split_segments(value, min: 1, max: 2)
+      return unless segments
+
+      return normalize_number(segments[0], min: 0.000001) if segments.length == 1
+
+      width = normalize_integer(segments[0], min: 1)
+      height = normalize_integer(segments[1], min: 1)
+
+      contiguous_segments([width, height], [])
+    end
+
+    def normalize_flip(value)
+      hash = value_hash(value)
+      if hash
+        horizontal = parse_boolean(field(hash, 'horizontal'))
+        vertical = parse_boolean(field(hash, 'vertical'))
+        return if horizontal.nil? && vertical.nil?
+
+        return 'both' if horizontal && vertical
+        return 'horizontal' if horizontal
+        return 'vertical' if vertical
+
+        return
+      end
+
+      string = normalize_string(value)
+      return string if FLIP_VALUES.include?(string)
+
+      segments = split_segments(value, min: 2, max: 2)
+      return unless segments
+
+      horizontal = parse_boolean(segments[0])
+      vertical = parse_boolean(segments[1])
+      return if horizontal.nil? || vertical.nil?
+
+      "#{horizontal}:#{vertical}"
+    end
+
+    def normalize_gradient(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_gradient_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 4)
+      return unless segments
+
+      colors = normalize_color_list(segments[0])
+      angle = normalize_number(segments[1]) if segments.length > 1
+      opacity = normalize_number(segments[2], min: 0, max: 1) if segments.length > 2
+      blend = normalize_non_empty_string(segments[3]) if segments.length > 3
+
+      contiguous_segments([colors], [angle, opacity, blend].first(segments.length - 1))
+    end
+
+    def normalize_gradient_hash(hash)
+      colors = normalize_color_list(field(hash, 'colors'))
+      angle = normalize_number(field(hash, 'angle'))
+      opacity = normalize_number(field(hash, 'opacity'), min: 0, max: 1)
+      blend = normalize_non_empty_string(field(hash, 'blend'))
+
+      contiguous_segments([colors], [angle, opacity, blend])
+    end
+
+    def normalize_monochrome(value)
+      boolean = parse_boolean(value)
+      return 'true' if boolean == true
+      return if boolean == false
+
+      normalize_color(value)
+    end
+
+    def normalize_negate(value)
+      hash = value_hash(value)
+      if hash
+        alpha = parse_boolean(field(hash, 'alpha'))
+        return unless [true, false].include?(alpha)
+
+        return "alpha:#{alpha}"
+      end
+
+      boolean = parse_boolean(value)
+      return 'true' if boolean == true
+      return if boolean == false
+
+      segments = split_segments(value, min: 2, max: 2)
+      return unless segments&.first == 'alpha'
+
+      alpha = parse_boolean(segments[1])
+      return unless [true, false].include?(alpha)
+
+      "alpha:#{alpha}"
+    end
+
+    def normalize_normalize(value)
+      hash = value_hash(value)
+      if hash
+        lower = normalize_number(field(hash, 'lower'))
+        upper = normalize_number(field(hash, 'upper'))
+
+        return contiguous_segments([lower, upper], [])
+      end
+
+      boolean = parse_boolean(value)
+      return 'true' if boolean == true
+      return if boolean == false
+
+      segments = split_segments(value, min: 2, max: 2)
+      return unless segments
+
+      lower = normalize_number(segments[0])
+      upper = normalize_number(segments[1])
+
+      contiguous_segments([lower, upper], [])
+    end
+
+    def normalize_padding(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_padding_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 4)
+      return unless segments
+
+      normalized = segments.map { |segment| normalize_integer(segment) }
+      return if normalized.any?(&:nil?)
+
+      normalized.join(':')
+    end
+
+    def normalize_padding_hash(hash)
+      all = normalize_integer(field(hash, 'all'))
+      return all if all
+
+      x = normalize_integer(field(hash, 'x'))
+      y = normalize_integer(field(hash, 'y'))
+      return contiguous_segments([x, y], []) if x || y
+
+      top = normalize_integer(field(hash, 'top'))
+      right = normalize_integer(field(hash, 'right'))
+      bottom = normalize_integer(field(hash, 'bottom'))
+      left = normalize_integer(field(hash, 'left'))
+
+      compact_json = compact_json_object(
+        hash,
+        'top' => top,
+        'right' => right,
+        'bottom' => bottom,
+        'left' => left
+      )
+      return unless compact_json
+
+      contiguous_segments([top, right, bottom, left], []) || compact_json
+    end
+
+    def normalize_rotate(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      if hash
+        angle = normalize_number(field(hash, 'angle'))
+        background = normalize_color(field(hash, 'background', 'bg'))
+
+        return contiguous_segments([angle], [background])
+      end
+
+      segments = split_segments(value, min: 1, max: 2)
+      return unless segments
+
+      angle = normalize_number(segments[0])
+      background = normalize_color(segments[1]) if segments.length > 1
+
+      contiguous_segments([angle], [background].first(segments.length - 1))
+    end
+
+    def normalize_sharpen(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return json_object(hash) if hash
+
+      normalize_true_or_number(value)
+    end
+
+    def normalize_watermark(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_watermark_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 4)
+      return unless segments
+
+      image_id = normalize_non_empty_string(segments[0])
+      gravity = normalize_gravity(segments[1]) if segments.length > 1
+      x = normalize_integer(segments[2]) if segments.length > 2
+      y = normalize_integer(segments[3]) if segments.length > 3
+
+      contiguous_segments([image_id], [gravity, x, y].first(segments.length - 1))
+    end
+
+    def normalize_watermark_hash(hash)
+      image_id = normalize_non_empty_string(field(hash, 'image_id', 'imageId', 'id'))
+      gravity = normalize_gravity(field(hash, 'gravity', 'g'))
+      x = normalize_integer(field(hash, 'x'))
+      y = normalize_integer(field(hash, 'y'))
+
+      contiguous_segments([image_id], [gravity, x, y])
+    end
+
+    def normalize_watermark_position(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_watermark_position_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 5)
+      return unless segments
+
+      gravity = normalize_gravity(segments[0])
+      x = normalize_integer(segments[1]) if segments.length > 1
+      y = normalize_integer(segments[2]) if segments.length > 2
+      opacity = normalize_number(segments[3], min: 0, max: 1) if segments.length > 3
+      blend = normalize_non_empty_string(segments[4]) if segments.length > 4
+
+      contiguous_segments([gravity], [x, y, opacity, blend].first(segments.length - 1))
+    end
+
+    def normalize_watermark_position_hash(hash)
+      gravity = normalize_gravity(field(hash, 'gravity', 'g'))
+      x = normalize_integer(field(hash, 'x'))
+      y = normalize_integer(field(hash, 'y'))
+      opacity = normalize_number(field(hash, 'opacity'), min: 0, max: 1)
+      blend = normalize_non_empty_string(field(hash, 'blend'))
+
+      contiguous_segments([gravity], [x, y, opacity, blend])
+    end
+
+    def normalize_watermark_shadow(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      boolean = parse_boolean(value)
+      return 'true' if boolean == true
+      return if boolean == false
+
+      hash = value_hash(value)
+      return normalize_watermark_shadow_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 4)
+      return unless segments
+
+      color = normalize_color(segments[0])
+      blur = normalize_number(segments[1]) if segments.length > 1
+      x = normalize_integer(segments[2]) if segments.length > 2
+      y = normalize_integer(segments[3]) if segments.length > 3
+
+      contiguous_segments([color], [blur, x, y].first(segments.length - 1))
+    end
+
+    def normalize_watermark_shadow_hash(hash)
+      color = normalize_color(field(hash, 'color'))
+      blur = normalize_number(field(hash, 'blur'))
+      x = normalize_integer(field(hash, 'x'))
+      y = normalize_integer(field(hash, 'y'))
+
+      contiguous_segments([color], [blur, x, y])
+    end
+
+    def normalize_watermark_size(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return normalize_watermark_size_hash(hash) if hash
+
+      segments = split_segments(value, min: 1, max: 3)
+      return unless segments
+
+      width = normalize_integer(segments[0], min: 1)
+      height = normalize_integer(segments[1], min: 1) if segments.length > 1
+      scale = normalize_number(segments[2], min: 0.000001) if segments.length > 2
+
+      contiguous_segments([width], [height, scale].first(segments.length - 1))
+    end
+
+    def normalize_watermark_size_hash(hash)
+      width = normalize_integer(field(hash, 'width', 'w'), min: 1)
+      height = normalize_integer(field(hash, 'height', 'h'), min: 1)
+      scale = normalize_number(field(hash, 'scale'), min: 0.000001)
+
+      contiguous_segments([width], [height, scale])
+    end
+
+    def normalize_text_or_json_object(value)
+      return normalize_json_string(value) if json_object_string?(value)
+
+      hash = value_hash(value)
+      return json_object(hash) if hash
+
+      normalize_non_empty_string(value)
+    end
+
+    def normalize_watermark_url(value)
+      string = normalize_non_empty_string(value)
+      return unless string
+
+      return Base64.strict_encode64(string) if valid_https_url?(string)
+
+      string if valid_base64_https_url?(string)
+    end
+
+    def normalize_zoom(value)
+      hash = value_hash(value)
+      if hash
+        factor = normalize_number(field(hash, 'factor'), min: 0.000001)
+        gravity = normalize_gravity(field(hash, 'gravity', 'g'))
+
+        return contiguous_segments([factor], [gravity])
+      end
+
+      segments = split_segments(value, min: 1, max: 2)
+      return unless segments
+
+      factor = normalize_number(segments[0], min: 0.000001)
+      gravity = normalize_gravity(segments[1]) if segments.length > 1
+
+      contiguous_segments([factor], [gravity].first(segments.length - 1))
+    end
+
+    def normalize_top_level_keys(hash)
+      hash.to_h.transform_keys(&:to_sym)
+    end
+
+    def value_hash(value)
+      return unless value.respond_to?(:to_hash)
+
+      value.to_hash.transform_keys(&:to_s)
+    end
+
+    def field(hash, *names)
+      names.each do |name|
+        return hash[name] if hash.key?(name)
+      end
+
+      nil
+    end
+
+    def field?(hash, *names)
+      names.any? { |name| hash.key?(name) }
+    end
+
+    def split_segments(value, min:, max:)
+      string = normalize_non_empty_string(value)
+      return unless string
+
+      segments = string.split(':', -1)
+      return unless segments.length.between?(min, max)
+      return if segments.any?(&:empty?)
+
+      segments
+    end
+
+    def contiguous_segments(required, optional)
+      return if required.any?(&:nil?)
+
+      last_present = optional.rindex { |segment| !segment.nil? }
+      selected_optional = last_present.nil? ? [] : optional[0..last_present]
+      return if selected_optional.any?(&:nil?)
+
+      (required + selected_optional).join(':')
+    end
+
+    def normalize_boolean_flag(value)
+      parse_boolean(value) == true ? 'true' : nil
+    end
+
+    def parse_boolean(value)
+      return true if value == true
+      return false if value == false
+      return true if value == 1
+      return false if value.is_a?(Numeric) && value.zero?
+
+      case normalize_string(value)
+      when 'true', '1'
+        true
+      when 'false', '0'
+        false
+      end
+    end
+
+    def normalize_true_or_number(value, min: nil, max: nil)
+      boolean = parse_boolean(value)
+      return 'true' if boolean == true
+      return if boolean == false
+
+      normalize_number(value, min: min, max: max)
+    end
+
+    def normalize_integer(value, min: nil, max: nil)
+      integer = parse_integer(value)
+      return if integer.nil?
+      return if min && integer < min
+      return if max && integer > max
+
+      integer.to_s
+    end
+
+    def parse_integer(value)
+      return value if value.is_a?(Integer)
+
+      if value.is_a?(Float)
+        return unless value.finite? && value == value.to_i
+
+        return value.to_i
+      end
+
+      string = normalize_non_empty_string(value)
+      return unless string&.match?(/\A[+-]?\d+\z/)
+
+      Integer(string)
+    end
+
+    def normalize_number(value, min: nil, max: nil)
+      number = parse_number(value)
+      return if number.nil?
+      return if min && number < min
+      return if max && number > max
+
+      format_number(number)
+    end
+
+    def parse_number(value)
+      return value.to_f if value.is_a?(Numeric) && value.to_f.finite?
+
+      string = normalize_non_empty_string(value)
+      return unless string
+
+      number = Float(string)
+      return unless number.finite?
+
+      number
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def format_number(number)
+      return number.to_i.to_s if number == number.to_i
+
+      number.to_s
+    end
+
+    def normalize_enum(value, values, aliases: {})
+      string = normalize_string(value)
+      return aliases[string] if aliases.key?(string)
+
+      string if values.include?(string)
+    end
+
+    def normalize_gravity(value)
+      string = normalize_string(value)
+      return GRAVITY_ALIASES[string] if GRAVITY_ALIASES.key?(string)
+
+      string if GRAVITY_VALUES.include?(string)
+    end
+
+    def normalize_color(value)
+      string = normalize_non_empty_string(value)
+      return unless string
+
+      string = string.delete_prefix('#')
+      return string.downcase if string.match?(/\A(?:[[:xdigit:]]{3}|[[:xdigit:]]{6}|[[:xdigit:]]{8})\z/)
+
+      string if rgb_color?(string)
+    end
+
+    def rgb_color?(string)
+      segments = string.split(':', -1)
+      return false unless [3, 4].include?(segments.length)
+
+      red, green, blue = segments.first(3).map { |segment| parse_integer(segment) }
+      return false unless [red, green, blue].all? { |part| part&.between?(0, 255) }
+      return true if segments.length == 3
+
+      alpha = parse_number(segments[3])
+      alpha&.between?(0, 1)
+    end
+
+    def normalize_color_list(value)
+      colors = value.is_a?(Array) ? value : normalize_non_empty_string(value)&.split(',', -1)
+      return unless colors&.length&.>= 2
+
+      normalized = colors.map { |color| normalize_color(color) }
+      return if normalized.any?(&:nil?)
+
+      normalized.join(',')
+    end
+
+    def normalize_non_empty_string(value)
+      string = value.to_s.strip
+      return if string.empty?
+
+      string
+    end
+
+    def normalize_string(value)
+      normalize_non_empty_string(value)&.downcase
+    end
+
+    def json_object_string?(value)
+      string = normalize_non_empty_string(value)
+      return false unless string&.start_with?('{')
+
+      JSON.parse(string).is_a?(Hash)
+    rescue JSON::ParserError
+      false
+    end
+
+    def normalize_json_string(value)
+      normalize_non_empty_string(value)
+    end
+
+    def compact_json_object(input_hash, fields)
+      return unless fields.values.any?
+      return if fields.any? { |key, item| field?(input_hash, key) && item.nil? }
+
+      JSON.generate(fields.compact)
+    end
+
+    def json_object(hash)
+      return if hash.empty?
+
+      JSON.generate(camelize_hash_keys(hash))
+    end
+
+    def camelize_hash_keys(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[camelize_key(key)] = value.is_a?(Hash) ? camelize_hash_keys(value) : value
+      end
+    end
+
+    def camelize_key(key)
+      key.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+    end
+
+    def valid_https_url?(value)
+      uri = URI.parse(value)
+      uri.is_a?(URI::HTTPS) && uri.host && !uri.host.empty?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def valid_base64_https_url?(value)
+      decoded = Base64.strict_decode64(value)
+      valid_https_url?(decoded)
+    rescue ArgumentError
+      false
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/imgwire/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imgwire
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imgwire
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Blackhawk Software, LLC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 2026-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +144,7 @@ files:
 - lib/imgwire/resources/images_resource.rb
 - lib/imgwire/resources/metrics_resource.rb
 - lib/imgwire/uploads.rb
+- lib/imgwire/url_transformations.rb
 - lib/imgwire/version.rb
 homepage: https://github.com/Blackhawk-Software/imgwire-ruby
 licenses: