Module: Imgwire::URLTransformations

Defined in:
lib/imgwire/url_transformations.rb

Overview

rubocop:disable Metrics/ModuleLength

Constant Summary collapse

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

Class Method Summary collapse

Class Method Details

.build_query(options) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/imgwire/url_transformations.rb', line 96

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

.camelize_hash_keys(hash) ⇒ Object 



882
883
884
885
886
 
# File 'lib/imgwire/url_transformations.rb', line 882

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

.camelize_key(key) ⇒ Object 



888
889
890
 
# File 'lib/imgwire/url_transformations.rb', line 888

def camelize_key(key)
  key.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
end

.compact_json_object(input_hash, fields) ⇒ Object 



869
870
871
872
873
874
 
# File 'lib/imgwire/url_transformations.rb', line 869

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

.contiguous_segments(required, optional) ⇒ Object 



710
711
712
713
714
715
716
717
718
 
# File 'lib/imgwire/url_transformations.rb', line 710

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

.field(hash, *names) ⇒ Object 



687
688
689
690
691
692
693
 
# File 'lib/imgwire/url_transformations.rb', line 687

def field(hash, *names)
  names.each do |name|
    return hash[name] if hash.key?(name)
  end

  nil
end

.field?(hash, *names) ⇒ Boolean

Returns:

  • (Boolean) 


695
696
697
 
# File 'lib/imgwire/url_transformations.rb', line 695

def field?(hash, *names)
  names.any? { |name| hash.key?(name) }
end

.format_number(number) ⇒ Object 



793
794
795
796
797
 
# File 'lib/imgwire/url_transformations.rb', line 793

def format_number(number)
  return number.to_i.to_s if number == number.to_i

  number.to_s
end

.json_object(hash) ⇒ Object 



876
877
878
879
880
 
# File 'lib/imgwire/url_transformations.rb', line 876

def json_object(hash)
  return if hash.empty?

  JSON.generate(camelize_hash_keys(hash))
end

.json_object_string?(value) ⇒ Boolean

Returns:

  • (Boolean) 


856
857
858
859
860
861
862
863
 
# File 'lib/imgwire/url_transformations.rb', line 856

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

.normalize_adjust(value) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/imgwire/url_transformations.rb', line 194

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

.normalize_boolean_flag(value) ⇒ Object 



720
721
722
 
# File 'lib/imgwire/url_transformations.rb', line 720

def normalize_boolean_flag(value)
  parse_boolean(value) == true ? 'true' : nil
end

.normalize_color(value) ⇒ Object 



813
814
815
816
817
818
819
820
821
 
# File 'lib/imgwire/url_transformations.rb', line 813

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

.normalize_color_list(value) ⇒ Object 



835
836
837
838
839
840
841
842
843
 
# File 'lib/imgwire/url_transformations.rb', line 835

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

.normalize_contrast(value) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/imgwire/url_transformations.rb', line 216

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

.normalize_crop(value) ⇒ Object 



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/imgwire/url_transformations.rb', line 236

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

.normalize_crop_hash(hash) ⇒ Object 



262
263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'lib/imgwire/url_transformations.rb', line 262

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

.normalize_duotone(value) ⇒ Object 



276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
 
# File 'lib/imgwire/url_transformations.rb', line 276

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

.normalize_enum(value, values, aliases: {}) ⇒ Object 



799
800
801
802
803
804
 
# File 'lib/imgwire/url_transformations.rb', line 799

def normalize_enum(value, values, aliases: {})
  string = normalize_string(value)
  return aliases[string] if aliases.key?(string)

  string if values.include?(string)
end

.normalize_extend(value) ⇒ Object 



296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/imgwire/url_transformations.rb', line 296

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

.normalize_extend_aspect_ratio(value) ⇒ Object 



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/imgwire/url_transformations.rb', line 334

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

.normalize_extend_hash(hash) ⇒ Object 



314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/imgwire/url_transformations.rb', line 314

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

.normalize_flip(value) ⇒ Object 



359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/imgwire/url_transformations.rb', line 359

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

.normalize_gradient(value) ⇒ Object 



386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
 
# File 'lib/imgwire/url_transformations.rb', line 386

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

.normalize_gradient_hash(hash) ⇒ Object 



403
404
405
406
407
408
409
410
 
# File 'lib/imgwire/url_transformations.rb', line 403

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

.normalize_gravity(value) ⇒ Object 



806
807
808
809
810
811
 
# File 'lib/imgwire/url_transformations.rb', line 806

def normalize_gravity(value)
  string = normalize_string(value)
  return GRAVITY_ALIASES[string] if GRAVITY_ALIASES.key?(string)

  string if GRAVITY_VALUES.include?(string)
end

.normalize_integer(value, min: nil, max: nil) ⇒ Object 



746
747
748
749
750
751
752
753
 
# File 'lib/imgwire/url_transformations.rb', line 746

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

.normalize_json_string(value) ⇒ Object 



865
866
867
 
# File 'lib/imgwire/url_transformations.rb', line 865

def normalize_json_string(value)
  normalize_non_empty_string(value)
end

.normalize_monochrome(value) ⇒ Object 



412
413
414
415
416
417
418
 
# File 'lib/imgwire/url_transformations.rb', line 412

def normalize_monochrome(value)
  boolean = parse_boolean(value)
  return 'true' if boolean == true
  return if boolean == false

  normalize_color(value)
end

.normalize_negate(value) ⇒ Object 



420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
 
# File 'lib/imgwire/url_transformations.rb', line 420

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

.normalize_non_empty_string(value) ⇒ Object 



845
846
847
848
849
850
 
# File 'lib/imgwire/url_transformations.rb', line 845

def normalize_non_empty_string(value)
  string = value.to_s.strip
  return if string.empty?

  string
end

.normalize_normalize(value) ⇒ Object 



442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
 
# File 'lib/imgwire/url_transformations.rb', line 442

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

.normalize_number(value, min: nil, max: nil) ⇒ Object 



770
771
772
773
774
775
776
777
 
# File 'lib/imgwire/url_transformations.rb', line 770

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

.normalize_padding(value) ⇒ Object 



464
465
466
467
468
469
470
471
472
473
474
475
476
477
 
# File 'lib/imgwire/url_transformations.rb', line 464

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

.normalize_padding_hash(hash) ⇒ Object 



479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/imgwire/url_transformations.rb', line 479

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

.normalize_rotate(value) ⇒ Object 



504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
 
# File 'lib/imgwire/url_transformations.rb', line 504

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

.normalize_rule(canonical, value) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/imgwire/url_transformations.rb', line 113

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

.normalize_sharpen(value) ⇒ Object 



524
525
526
527
528
529
530
531
 
# File 'lib/imgwire/url_transformations.rb', line 524

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

.normalize_string(value) ⇒ Object 



852
853
854
 
# File 'lib/imgwire/url_transformations.rb', line 852

def normalize_string(value)
  normalize_non_empty_string(value)&.downcase
end

.normalize_text_or_json_object(value) ⇒ Object 



641
642
643
644
645
646
647
648
 
# File 'lib/imgwire/url_transformations.rb', line 641

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

.normalize_top_level_keys(hash) ⇒ Object 



677
678
679
 
# File 'lib/imgwire/url_transformations.rb', line 677

def normalize_top_level_keys(hash)
  hash.to_h.transform_keys(&:to_sym)
end

.normalize_true_or_number(value, min: nil, max: nil) ⇒ Object 



738
739
740
741
742
743
744
 
# File 'lib/imgwire/url_transformations.rb', line 738

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

.normalize_watermark(value) ⇒ Object 



533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
 
# File 'lib/imgwire/url_transformations.rb', line 533

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

.normalize_watermark_hash(hash) ⇒ Object 



550
551
552
553
554
555
556
557
 
# File 'lib/imgwire/url_transformations.rb', line 550

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

.normalize_watermark_position(value) ⇒ Object 



559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
 
# File 'lib/imgwire/url_transformations.rb', line 559

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

.normalize_watermark_position_hash(hash) ⇒ Object 



577
578
579
580
581
582
583
584
585
 
# File 'lib/imgwire/url_transformations.rb', line 577

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

.normalize_watermark_shadow(value) ⇒ Object 



587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# File 'lib/imgwire/url_transformations.rb', line 587

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

.normalize_watermark_shadow_hash(hash) ⇒ Object 



608
609
610
611
612
613
614
615
 
# File 'lib/imgwire/url_transformations.rb', line 608

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

.normalize_watermark_size(value) ⇒ Object 



617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
 
# File 'lib/imgwire/url_transformations.rb', line 617

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

.normalize_watermark_size_hash(hash) ⇒ Object 



633
634
635
636
637
638
639
 
# File 'lib/imgwire/url_transformations.rb', line 633

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

.normalize_watermark_url(value) ⇒ Object 



650
651
652
653
654
655
656
657
 
# File 'lib/imgwire/url_transformations.rb', line 650

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

.normalize_zoom(value) ⇒ Object 



659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
 
# File 'lib/imgwire/url_transformations.rb', line 659

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

.parse_boolean(value) ⇒ Object 



724
725
726
727
728
729
730
731
732
733
734
735
736
 
# File 'lib/imgwire/url_transformations.rb', line 724

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

.parse_integer(value) ⇒ Object 



755
756
757
758
759
760
761
762
763
764
765
766
767
768
 
# File 'lib/imgwire/url_transformations.rb', line 755

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

.parse_number(value) ⇒ Object 



779
780
781
782
783
784
785
786
787
788
789
790
791
 
# File 'lib/imgwire/url_transformations.rb', line 779

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

.rgb_color?(string) ⇒ Boolean

Returns:

  • (Boolean) 


823
824
825
826
827
828
829
830
831
832
833
 
# File 'lib/imgwire/url_transformations.rb', line 823

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

.split_segments(value, min:, max:) ⇒ Object 



699
700
701
702
703
704
705
706
707
708
 
# File 'lib/imgwire/url_transformations.rb', line 699

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

.valid_base64_https_url?(value) ⇒ Boolean

Returns:

  • (Boolean) 


899
900
901
902
903
904
 
# File 'lib/imgwire/url_transformations.rb', line 899

def valid_base64_https_url?(value)
  decoded = Base64.strict_decode64(value)
  valid_https_url?(decoded)
rescue ArgumentError
  false
end

.valid_https_url?(value) ⇒ Boolean

Returns:

  • (Boolean) 


892
893
894
895
896
897
 
# File 'lib/imgwire/url_transformations.rb', line 892

def valid_https_url?(value)
  uri = URI.parse(value)
  uri.is_a?(URI::HTTPS) && uri.host && !uri.host.empty?
rescue URI::InvalidURIError
  false
end

.value_hash(value) ⇒ Object 



681
682
683
684
685
 
# File 'lib/imgwire/url_transformations.rb', line 681

def value_hash(value)
  return unless value.respond_to?(:to_hash)

  value.to_hash.transform_keys(&:to_s)
end