Class: Cloudinary::Utils

Inherits:
Object show all
Defined in:
lib/cloudinary/utils.rb

Constant Summary collapse

SHARED_CDN =
Deprecated.

Use Cloudinary::SHARED_CDN

Cloudinary::SHARED_CDN
DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION = 
{:width => :auto, :crop => :limit}
CONDITIONAL_OPERATORS = 
{
  "=" => 'eq',
  "!=" => 'ne',
  "<" => 'lt',
  ">" => 'gt',
  "<=" => 'lte',
  ">=" => 'gte',
  "&&" => 'and',
  "||" => 'or'
}
CONDITIONAL_PARAMETERS = 
{
  "width" => "w",
  "height" => "h",
  "aspect_ratio" => "ar",
  "page_count" => "pc",
  "face_count" => "fc"
}
LAYER_KEYWORD_PARAMS = 
[
  [:font_weight     ,"normal"],
  [:font_style      ,"normal"],
  [:text_decoration ,"none"],
  [:text_align      ,nil],
  [:stroke          ,"none"],
]
IMAGE_FORMATS = 
%w(ai bmp bpg djvu eps eps3 flif gif h264 hdp hpx ico j2k jp2 jpc jpe jpg miff mka mp4 pdf png psd svg tif tiff wdp webm webp zip )
AUDIO_FORMATS = 
%w(aac aifc aiff flac m4a mp3 ogg wav)
VIDEO_FORMATS = 
%w(3g2 3gp asf avi flv h264 m2t m2v m3u8 mka mov mp4 mpeg ogv ts webm wmv )
@@json_decode = 
false

Class Method Summary collapse

Class Method Details

.api_sign_request(params_to_sign, api_secret) ⇒ Object 



266
267
268
269
 
# File 'lib/cloudinary/utils.rb', line 266

def self.api_sign_request(params_to_sign, api_secret)
  to_sign = api_string_to_sign(params_to_sign)
  Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
end

.api_string_to_sign(params_to_sign) ⇒ Object 



262
263
264
 
# File 'lib/cloudinary/utils.rb', line 262

def self.api_string_to_sign(params_to_sign)
  params_to_sign.map{|k,v| [k.to_s, v.is_a?(Array) ? v.join(",") : v]}.reject{|k,v| v.nil? || v == ""}.sort_by(&:first).map{|k,v| "#{k}=#{v}"}.join("&")
end

.archive_params(options = {}) ⇒ Object

Returns a Hash of parameters used to create an archive

Parameters:

  • options (Hash) (defaults to: {}) 


726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
 
# File 'lib/cloudinary/utils.rb', line 726

def self.archive_params(options = {})
  options = Cloudinary::Utils.symbolize_keys options
  {
    :timestamp=>(options[:timestamp] || Time.now.to_i),
    :type=>options[:type],
    :mode => options[:mode],
    :target_format => options[:target_format],
    :target_public_id=> options[:target_public_id],
    :flatten_folders=>Cloudinary::Utils.as_safe_bool(options[:flatten_folders]),
    :flatten_transformations=>Cloudinary::Utils.as_safe_bool(options[:flatten_transformations]),
    :use_original_filename=>Cloudinary::Utils.as_safe_bool(options[:use_original_filename]),
    :async=>Cloudinary::Utils.as_safe_bool(options[:async]),
    :notification_url=>options[:notification_url],
    :target_tags=>options[:target_tags] && Cloudinary::Utils.build_array(options[:target_tags]),
    :keep_derived=>Cloudinary::Utils.as_safe_bool(options[:keep_derived]),
    :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]),
    :public_ids=>options[:public_ids] && Cloudinary::Utils.build_array(options[:public_ids]),
    :prefixes=>options[:prefixes] && Cloudinary::Utils.build_array(options[:prefixes]),
    :transformations => build_eager(options[:transformations])
  }
end

.as_bool(value) ⇒ Object 



660
661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/cloudinary/utils.rb', line 660

def self.as_bool(value)
  case value
  when nil then nil
  when String then value.downcase == "true" || value == "1"
  when TrueClass then true
  when FalseClass then false
  when Fixnum then value != 0
  when Symbol then value == :true
  else
    raise "Invalid boolean value #{value} of type #{value.class}"
  end
end

.as_safe_bool(value) ⇒ Object 



673
674
675
676
677
678
679
 
# File 'lib/cloudinary/utils.rb', line 673

def self.as_safe_bool(value)
  case as_bool(value)
  when nil then nil
  when TrueClass then 1
  when FalseClass then 0
  end
end

.asset_file_name(path) ⇒ Object 



560
561
562
563
564
565
566
 
# File 'lib/cloudinary/utils.rb', line 560

def self.asset_file_name(path)
  data = Cloudinary.app_root.join(path).read(:mode=>"rb")
  ext = path.extname
  md5 = Digest::MD5.hexdigest(data)
  public_id = "#{path.basename(ext)}-#{md5}"
  "#{public_id}#{ext}"
end

.build_array(array) ⇒ Object 



601
602
603
604
605
606
607
 
# File 'lib/cloudinary/utils.rb', line 601

def self.build_array(array)
  case array
    when Array then array
    when nil then []
    else [array]
  end
end

.build_eager(eager) ⇒ Object 



749
750
751
752
753
754
755
756
757
 
# File 'lib/cloudinary/utils.rb', line 749

def self.build_eager(eager)
  return nil if eager.nil?
  Cloudinary::Utils.build_array(eager).map do
  |transformation, format|
    transformation = transformation.clone
    format = transformation.delete(:format) || format
    [Cloudinary::Utils.generate_transformation_string(transformation, true), format].compact.join("/")
  end.join("|")
end

.cloudinary_api_url(action = 'upload', options = {}) ⇒ Object 



465
466
467
468
469
470
 
# File 'lib/cloudinary/utils.rb', line 465

def self.cloudinary_api_url(action = 'upload', options = {})
  cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
  cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, "Must supply cloud_name")
  resource_type = options[:resource_type] || "image"
  return [cloudinary, "v1_1", cloud_name, resource_type, action].join("/")
end

.cloudinary_url(public_id, options = {}) ⇒ Object 



551
552
553
554
555
556
557
558
 
# File 'lib/cloudinary/utils.rb', line 551

def self.cloudinary_url(public_id, options = {})
  if options[:type].to_s == 'authenticated' && !options[:sign_url]
    result = signed_download_url(public_id, options)
  else
    result = unsigned_download_url(public_id, options)
  end
  return result
end

.config_option_consume(options, option_name, default_value = nil) ⇒ Object 



655
656
657
658
 
# File 'lib/cloudinary/utils.rb', line 655

def self.config_option_consume(options, option_name, default_value = nil)
  return options.delete(option_name) if options.include?(option_name)
  return Cloudinary.config.send(option_name) || default_value
end

.deep_symbolize_keys(object) ⇒ Object 



707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
 
# File 'lib/cloudinary/utils.rb', line 707

def self.deep_symbolize_keys(object)
  case object
  when Hash
    result = {}
    object.each do |key, value|
      key = key.to_sym rescue key
      result[key] = deep_symbolize_keys(value)
    end
    result
  when Array
    object.map{|e| deep_symbolize_keys(e)}
  else
    object
  end
end

.download_archive_url(options = {}) ⇒ String

Returns a URL that when invokes creates an archive and returns it.

Parameters:

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :resource_type (String|Symbol) —

    The resource type of files to include in the archive. Must be one of :image | :video | :raw

  • :type (String|Symbol) — default: :upload —

    The specific file type of resources: :upload|:private|:authenticated

  • :tags (String|Symbol|Array) — default: nil —

    list of tags to include in the archive

  • :public_ids (String|Array<String>) — default: nil —

    list of public_ids to include in the archive

  • :prefixes (String|Array<String>) — default: nil —

    Optional list of prefixes of public IDs (e.g., folders).

  • :transformations (String|Array<String>) —

    Optional list of transformations. The derived images of the given transformations are included in the archive. Using the string representation of multiple chained transformations as we use for the ‘eager’ upload parameter.

  • :mode (String|Symbol) — default: :create —

    return the generated archive file or to store it as a raw resource and return a JSON with URLs for accessing the archive. Possible values: :download, :create

  • :target_format (String|Symbol) — default: :zip
  • :target_public_id (String) —

    Optional public ID of the generated raw resource. Relevant only for the create mode. If not specified, random public ID is generated.

  • :flatten_folders (boolean) — default: false —

    If true, flatten public IDs with folders to be in the root of the archive. Add numeric counter to the file name in case of a name conflict.

  • :flatten_transformations (boolean) — default: false —

    If true, and multiple transformations are given, flatten the folder structure of derived images and store the transformation details on the file name instead.

  • :use_original_filename (boolean) —

    Use the original file name of included images (if available) instead of the public ID.

  • :async (boolean) — default: false —

    If true, return immediately and perform the archive creation in the background. Relevant only for the create mode.

  • :notification_url (String) —

    Optional URL to send an HTTP post request (webhook) when the archive creation is completed.

  • String|Array (String|Array<String] :target_tags Optional array. Allows assigning one or more tag to the generated archive file (for later housekeeping via the admin API).) —

    :target_tags Optional array. Allows assigning one or more tag to the generated archive file (for later housekeeping via the admin API).

  • :keep_derived (String) — default: false —

    keep the derived images used for generating the archive

Returns:



528
529
530
531
 
# File 'lib/cloudinary/utils.rb', line 528

def self.download_archive_url(options = {})
  cloudinary_params = sign_request(Cloudinary::Utils.archive_params(options.merge(:mode => "download")), options)
  return Cloudinary::Utils.cloudinary_api_url("generate_archive", options) + "?" + hash_query_params(cloudinary_params)
end

.download_zip_url(options = {}) ⇒ Object

Returns a URL that when invokes creates an zip archive and returns it.

See Also:



536
537
538
 
# File 'lib/cloudinary/utils.rb', line 536

def self.download_zip_url(options = {})
  download_archive_url(options.merge(:target_format => "zip"))
end

.encode_double_array(array) ⇒ Object 



617
618
619
620
621
622
623
624
 
# File 'lib/cloudinary/utils.rb', line 617

def self.encode_double_array(array)
  array = build_array(array)
  if array.length > 0 && array[0].is_a?(Array)
    return array.map{|a| build_array(a).join(",")}.join("|")
  else
    return array.join(",")
  end
end

.encode_hash(hash) ⇒ Object 



609
610
611
612
613
614
615
 
# File 'lib/cloudinary/utils.rb', line 609

def self.encode_hash(hash)
  case hash
    when Hash then hash.map{|k,v| "#{k}=#{v}"}.join("|")
    when nil then ""
    else hash
  end
end

.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten) ⇒ Object 



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/cloudinary/utils.rb', line 389

def self.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
  type ||= :upload
  if !url_suffix.blank?
    case
    when resource_type.to_s == "image" && type.to_s == "upload"
      resource_type = "images"
      type = nil
    when resource_type.to_s == "image" && type.to_s == "private"
      resource_type = "private_images"
      type = nil
    when resource_type.to_s == "raw" && type.to_s == "upload"
      resource_type = "files"
      type = nil
    else
      raise(CloudinaryException, "URL Suffix only supported for image/upload, image/private and raw/upload")
    end
  end
  if use_root_path
    if (resource_type.to_s == "image" && type.to_s == "upload") || (resource_type.to_s == "images" && type.blank?)
      resource_type = nil
      type = nil
    else
      raise(CloudinaryException, "Root path only supported for image/upload")
    end
  end
  if shorten && resource_type.to_s == "image" && type.to_s == "upload"
    resource_type = "iu"
    type = nil
  end
  [resource_type, type]
end

.finalize_source(source, format, url_suffix) ⇒ Object 



369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/cloudinary/utils.rb', line 369

def self.finalize_source(source, format, url_suffix)
  source = source.gsub(%r(([^:])//), '\1/')
  if source.match(%r(^https?:/)i)
    source = smart_escape(source)
    source_to_sign = source
  else
    source = smart_escape(URI.decode(source))
    source_to_sign = source
    unless url_suffix.blank?
      raise(CloudinaryException, "url_suffix should not include . or /") if url_suffix.match(%r([\./]))
      source = "#{source}/#{url_suffix}"
    end
    if !format.blank?
      source = "#{source}.#{format}"
      source_to_sign = "#{source_to_sign}.#{format}"
    end
  end
  [source, source_to_sign]
end

.generate_responsive_breakpoints_string(breakpoints) ⇒ Object 



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/cloudinary/utils.rb', line 271

def self.generate_responsive_breakpoints_string(breakpoints)
  return nil if breakpoints.nil?
  breakpoints = build_array(breakpoints)

  breakpoints.map do |breakpoint_settings|
    unless breakpoint_settings.nil?
      breakpoint_settings = breakpoint_settings.clone
      transformation =  breakpoint_settings.delete(:transformation) || breakpoint_settings.delete("transformation")
      if transformation
        breakpoint_settings[:transformation] = Cloudinary::Utils.generate_transformation_string(transformation.clone, true)
      end 
    end
    breakpoint_settings

  end.to_json
end

.generate_transformation_string(options = {}, allow_implicit_crop_mode = false) ⇒ Object

Warning: options are being destructively updated!



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
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
 
# File 'lib/cloudinary/utils.rb', line 32

def self.generate_transformation_string(options={}, allow_implicit_crop_mode = false)
  # allow_implicit_crop_mode was added to support height and width parameters without specifying a crop mode.
  # This only apply to this (cloudinary_gem) SDK

  if options.is_a?(Array)
    return options.map{|base_transformation| generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode)}.join("/")
  end

  symbolize_keys!(options)

  responsive_width = config_option_consume(options, :responsive_width) 
  size = options.delete(:size)
  options[:width], options[:height] = size.split("x") if size
  width = options[:width]
  width = width.to_s if width.is_a?(Symbol)
  height = options[:height]
  has_layer = options[:overlay].present? || options[:underlay].present?

  crop = options.delete(:crop)
  angle = build_array(options.delete(:angle)).join(".")

  no_html_sizes = has_layer || angle.present? || crop.to_s == "fit" || crop.to_s == "limit" || crop.to_s == "lfill"
  options.delete(:width) if width && (width.to_f < 1 || no_html_sizes || width == "auto" || responsive_width)
  options.delete(:height) if height && (height.to_f < 1 || no_html_sizes || responsive_width)

  width=height=nil if crop.nil? && !has_layer && width != "auto" && !allow_implicit_crop_mode

  background = options.delete(:background)
  background = background.sub(/^#/, 'rgb:') if background

  color = options.delete(:color)
  color = color.sub(/^#/, 'rgb:') if color

  base_transformations = build_array(options.delete(:transformation))
  if base_transformations.any?{|base_transformation| base_transformation.is_a?(Hash)}
    base_transformations = base_transformations.map do
      |base_transformation|
      base_transformation.is_a?(Hash) ? generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode) : generate_transformation_string({:transformation=>base_transformation}, allow_implicit_crop_mode)
    end
  else
    named_transformation = base_transformations.join(".")
    base_transformations = []
  end

  effect = options.delete(:effect)
  effect = Array(effect).flatten.join(":") if effect.is_a?(Array) || effect.is_a?(Hash)

  border = options.delete(:border)
  if border.is_a?(Hash)
    border = "#{border[:width] || 2}px_solid_#{(border[:color] || "black").sub(/^#/, 'rgb:')}"
  elsif border.to_s =~ /^\d+$/ # fallback to html border attribute
    options[:border] = border
    border = nil
  end
  flags = build_array(options.delete(:flags)).join(".")
  dpr = config_option_consume(options, :dpr)

  if options.include? :offset
    options[:start_offset], options[:end_offset] = split_range options.delete(:offset)
  end

  overlay = process_layer(options.delete(:overlay))
  underlay = process_layer(options.delete(:underlay))
  ifValue = process_if(options.delete(:if))

  params = {
    :a   => angle,
    :b   => background,
    :bo  => border,
    :c   => crop,
    :co  => color,
    :dpr => dpr,
    :e   => effect,
    :fl  => flags,
    :h   => height,
    :l  => overlay,
    :t   => named_transformation,
    :u  => underlay,
    :w   => width
  }
  {
    :ar => :aspect_ratio,
    :ac => :audio_codec,
    :br => :bit_rate,
    :cs => :color_space,
    :d  => :default_image,
    :dl => :delay,
    :dn => :density,
    :du => :duration,
    :eo => :end_offset,
    :f  => :fetch_format,
    :g  => :gravity,
    :o  => :opacity,
    :p  => :prefix,
    :pg => :page,
    :q  => :quality,
    :r  => :radius,
    :af => :audio_frequency,
    :so => :start_offset,
    :vc => :video_codec,
    :vs => :video_sampling,
    :x  => :x,
    :y  => :y,
    :z  => :zoom
  }.each do
    |param, option|
    params[param] = options.delete(option)
  end

  params[:vc] = process_video_params params[:vc] if params[:vc].present?
  [:so, :eo, :du].each do |range_value|
    params[range_value] = norm_range_value params[range_value] if params[range_value].present?
  end

  raw_transformation = options.delete(:raw_transformation)
  transformation = params.reject{|_k,v| v.blank?}.map{|k,v| "#{k}_#{v}"}.sort
  transformation = transformation.join(",")
  transformation = [ifValue, transformation, raw_transformation].reject(&:blank?).join(",")

  transformations = base_transformations << transformation
  if responsive_width
    responsive_width_transformation = Cloudinary.config.responsive_width_transformation || DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION
    transformations << generate_transformation_string(responsive_width_transformation.clone, allow_implicit_crop_mode)
  end

  if width.to_s == "auto" || responsive_width
    options[:responsive] = true
  end
  if dpr.to_s == "auto"
    options[:hidpi] = true
  end

  transformations.reject(&:blank?).join("/")
end

.json_decode(str) ⇒ Object 



585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/cloudinary/utils.rb', line 585

def self.json_decode(str)
  if !@@json_decode
    @@json_decode = true
    begin
      require 'json'
    rescue LoadError
      begin
        require 'active_support/json'
      rescue LoadError
        raise LoadError, "Please add the json gem or active_support to your Gemfile"
      end
    end
  end
  defined?(JSON) ? JSON.parse(str) : ActiveSupport::JSON.decode(str)
end

.private_download_url(public_id, format, options = {}) ⇒ Object 



481
482
483
484
485
486
487
488
489
490
491
492
 
# File 'lib/cloudinary/utils.rb', line 481

def self.private_download_url(public_id, format, options = {})
  cloudinary_params = sign_request({
      :timestamp=>Time.now.to_i,
      :public_id=>public_id,
      :format=>format,
      :type=>options[:type],
      :attachment=>options[:attachment],
      :expires_at=>options[:expires_at] && options[:expires_at].to_i
    }, options)

  return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + hash_query_params(cloudinary_params)
end

.process_if(ifValue) ⇒ string

Parse “if” parameter Translates the condition if provided.

Returns:

  • (string) —

    “if_” + ifValue



171
172
173
174
175
176
177
178
179
180
 
# File 'lib/cloudinary/utils.rb', line 171

def self.process_if(ifValue)
  if ifValue
    ifValue = ifValue.gsub(
      /(#{CONDITIONAL_PARAMETERS.keys.join("|")}|[=<>&|!]+)/,
      CONDITIONAL_PARAMETERS.merge(CONDITIONAL_OPERATORS))
      .gsub(/[ _]+/, "_")

    ifValue = "if_" + ifValue
  end
end

.random_public_id ⇒ Object 



575
576
577
578
 
# File 'lib/cloudinary/utils.rb', line 575

def self.random_public_id
  sr = defined?(ActiveSupport::SecureRandom) ? ActiveSupport::SecureRandom : SecureRandom
  sr.base64(20).downcase.gsub(/[^a-z0-9]/, "").sub(/^[0-9]+/, '')[0,20]
end

.resource_type_for_format(format) ⇒ Object 



642
643
644
645
646
647
648
649
650
651
652
653
 
# File 'lib/cloudinary/utils.rb', line 642

def self.resource_type_for_format(format)
  case
  when self.supported_format?(format, IMAGE_FORMATS)
    'image'
  when self.supported_format?(format, VIDEO_FORMATS)
    'video'
  when self.supported_format?(format, AUDIO_FORMATS)
    'audio'
  else
    'raw'
  end
end

.safe_blank?(value) ⇒ Boolean

Returns:

  • (Boolean) 


681
682
683
 
# File 'lib/cloudinary/utils.rb', line 681

def self.safe_blank?(value)
  value.nil? || value == "" || value == []
end

.sign_request(params, options = {}) ⇒ Object 



472
473
474
475
476
477
478
479
 
# File 'lib/cloudinary/utils.rb', line 472

def self.sign_request(params, options={})
  api_key = options[:api_key] || Cloudinary.config.api_key || raise(CloudinaryException, "Must supply api_key")
  api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise(CloudinaryException, "Must supply api_secret")
  params = params.reject{|k, v| self.safe_blank?(v)}
  params[:signature] = Cloudinary::Utils.api_sign_request(params, api_secret)
  params[:api_key] = api_key
  params
end

.signed_download_url(public_id, options = {}) ⇒ Object 



540
541
542
543
544
545
546
547
548
549
 
# File 'lib/cloudinary/utils.rb', line 540

def self.signed_download_url(public_id, options = {})
  aws_private_key_path = options[:aws_private_key_path] || Cloudinary.config.aws_private_key_path || raise(CloudinaryException, "Must supply aws_private_key_path")
  aws_key_pair_id = options[:aws_key_pair_id] || Cloudinary.config.aws_key_pair_id || raise(CloudinaryException, "Must supply aws_key_pair_id")
  authenticated_distribution = options[:authenticated_distribution] || Cloudinary.config.authenticated_distribution || raise(CloudinaryException, "Must supply authenticated_distribution")
  @signers ||= Hash.new{|h,k| path, id = k; h[k] = AwsCfSigner.new(path, id)}
  signer = @signers[[aws_private_key_path, aws_key_pair_id]]
  url = Cloudinary::Utils.unsigned_download_url(public_id, {:type=>:authenticated}.merge(options).merge(:secure=>true, :secure_distribution=>authenticated_distribution, :private_cdn=>true))
  expires_at = options[:expires_at] || (Time.now+3600)
  signer.sign(url, :ending => expires_at)
end

.signed_preloaded_image(result) ⇒ Object 



580
581
582
 
# File 'lib/cloudinary/utils.rb', line 580

def self.signed_preloaded_image(result)
  "#{result["resource_type"]}/#{result["type"] || "upload"}/v#{result["version"]}/#{[result["public_id"], result["format"]].reject(&:blank?).join(".")}##{result["signature"]}"
end

.smart_escape(string, unsafe = /([^a-zA-Z0-9_.\-\/:]+)/) ⇒ Object

Based on CGI::unescape. In addition does not escape / :



569
570
571
572
573
 
# File 'lib/cloudinary/utils.rb', line 569

def self.smart_escape(string, unsafe = /([^a-zA-Z0-9_.\-\/:]+)/)
  string.gsub(unsafe) do
    '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
  end
end

.supported_format?(format, formats) ⇒ Boolean

Returns:

  • (Boolean) 


636
637
638
639
640
 
# File 'lib/cloudinary/utils.rb', line 636

def self.supported_format?( format, formats)
  format = format.to_s.downcase
  extension = format =~ /\./ ? format.split('.').last : format
  formats.include?(extension)
end

.supported_image_format?(format) ⇒ Boolean

Returns:

  • (Boolean) 


632
633
634
 
# File 'lib/cloudinary/utils.rb', line 632

def self.supported_image_format?(format)
  supported_format? format, IMAGE_FORMATS
end

.symbolize_keys(h) ⇒ Object 



685
686
687
688
689
690
691
692
693
 
# File 'lib/cloudinary/utils.rb', line 685

def self.symbolize_keys(h)
  new_h = Hash.new
  if (h.respond_to? :keys)
    h.keys.each do |key|
      new_h[(key.to_sym rescue key)] = h[key]
    end
  end
  new_h
end

.symbolize_keys!(h) ⇒ Object 



696
697
698
699
700
701
702
703
704
 
# File 'lib/cloudinary/utils.rb', line 696

def self.symbolize_keys!(h)
  if (h.respond_to? :keys) && (h.respond_to? :delete)
    h.keys.each do |key|
      value = h.delete(key)
      h[(key.to_sym rescue key)] = value
    end
  end
  h
end

.text_style(layer) ⇒ Object 



241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/cloudinary/utils.rb', line 241

def self.text_style(layer)
  font_family = layer[:font_family]
  font_size   = layer[:font_size]
  keywords    = []
  LAYER_KEYWORD_PARAMS.each do |attr, default_value|
    attr_value = layer[attr] || default_value
    keywords.push(attr_value) unless attr_value == default_value
  end
  letter_spacing = layer[:letter_spacing]
  keywords.push("letter_spacing_#{letter_spacing}") unless letter_spacing.blank?
  line_spacing = layer[:line_spacing]
  keywords.push("line_spacing_#{line_spacing}") unless line_spacing.blank?
  if !font_size.blank? || !font_family.blank? || !keywords.empty?
    raise(CloudinaryException, "Must supply font_family for text in overlay/underlay") if font_family.blank?
    raise(CloudinaryException, "Must supply font_size for text in overlay/underlay") if font_size.blank?
    keywords.unshift(font_size)
    keywords.unshift(font_family)
    keywords.reject(&:blank?).join("_")
  end
end

.unsigned_download_url(source, options = {}) ⇒ Object

Warning: options are being destructively updated!

Raises:



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/cloudinary/utils.rb', line 289

def self.unsigned_download_url(source, options = {})

  type = options.delete(:type)

  options[:fetch_format] ||= options.delete(:format) if type.to_s == "fetch"
  transformation = self.generate_transformation_string(options)

  resource_type = options.delete(:resource_type)
  version = options.delete(:version)
  format = options.delete(:format)
  cloud_name = config_option_consume(options, :cloud_name) || raise(CloudinaryException, "Must supply cloud_name in tag or in configuration")

  secure = options.delete(:secure)
  ssl_detected = options.delete(:ssl_detected)
  secure = ssl_detected || Cloudinary.config.secure if secure.nil?
  private_cdn = config_option_consume(options, :private_cdn)
  secure_distribution = config_option_consume(options, :secure_distribution)
  cname = config_option_consume(options, :cname)
  shorten = config_option_consume(options, :shorten)
  force_remote = options.delete(:force_remote)
  cdn_subdomain = config_option_consume(options, :cdn_subdomain)
  secure_cdn_subdomain = config_option_consume(options, :secure_cdn_subdomain)
  sign_url = config_option_consume(options, :sign_url)
  secret = config_option_consume(options, :api_secret)
  sign_version = config_option_consume(options, :sign_version) # Deprecated behavior
  url_suffix = options.delete(:url_suffix)
  use_root_path = config_option_consume(options, :use_root_path)

  raise(CloudinaryException, "URL Suffix only supported in private CDN") if url_suffix.present? and not private_cdn

  original_source = source
  return original_source if source.blank?
  if defined?(CarrierWave::Uploader::Base) && source.is_a?(CarrierWave::Uploader::Base)
    resource_type ||= source.resource_type
    type ||= source.storage_type
    source = format.blank? ? source.filename : source.full_public_id
  end
  type = type.to_s unless type.nil?
  resource_type ||= "image"
  source = source.to_s
  if !force_remote
    return original_source if (type.nil? || type == "asset") && source.match(%r(^https?:/)i)
    if source.start_with?("/")
      if source.start_with?("/images/")
        source = source.sub(%r(/images/), '')
      else
        return original_source
      end
    end
    @metadata ||= defined?(Cloudinary::Static) ? Cloudinary::Static.metadata : {}
    if type == "asset" && @metadata["images/#{source}"]
      return original_source if !Cloudinary.config.static_image_support
      source = @metadata["images/#{source}"]["public_id"]
      source += File.extname(original_source) if !format
    elsif type == "asset"
      return original_source # requested asset, but no metadata - probably local file. return.
    end
  end

  resource_type, type = finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
  source, source_to_sign = finalize_source(source, format, url_suffix)

  version ||= 1 if source_to_sign.include?("/") and !source_to_sign.match(/^v[0-9]+/) and !source_to_sign.match(/^https?:\//)
  version &&= "v#{version}"

  transformation = transformation.gsub(%r(([^:])//), '\1/')
  if sign_url
    to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
    i = 0
    while to_sign != CGI.unescape(to_sign) && i <10
      to_sign = CGI.unescape(to_sign)
      i = i + 1
    end
    signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
  end

  prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
    source = [prefix, resource_type, type, signature, transformation, version, source].reject(&:blank?).join("/")
end

.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution) ⇒ Object

Creates the URL prefix for the cloudinary resource URL

cdn_subdomain and secure_cdn_subdomain

  1. Customers in shared distribution (e.g. res.cloudinary.com)

    if cdn_domain is true uses res-[1-5 ].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.

  2. Customers with private cdn

    if cdn_domain is true uses cloudname-res-[1-5 ].cloudinary.com for http

    if secure_cdn_domain is true uses cloudname-res-[1-5 ].cloudinary.com for https (please contact support if you require this)

  3. Customers with cname

    if cdn_domain is true uses a.cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.



436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'lib/cloudinary/utils.rb', line 436

def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
  return "/res#{cloud_name}" if cloud_name.start_with?("/") # For development

  shared_domain = !private_cdn

  if secure
    if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
      secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
    end
    shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
    secure_cdn_subdomain = cdn_subdomain if secure_cdn_subdomain.nil? && shared_domain

    if secure_cdn_subdomain
      secure_distribution = secure_distribution.gsub('res.cloudinary.com', "res-#{(Zlib::crc32(source) % 5) + 1}.cloudinary.com")
    end

    prefix = "https://#{secure_distribution}"
  elsif cname
    subdomain = cdn_subdomain ? "a#{(Zlib::crc32(source) % 5) + 1}." : ""
    prefix = "http://#{subdomain}#{cname}"
  else
    host = [private_cdn ? "#{cloud_name}-" : "", "res", cdn_subdomain ? "-#{(Zlib::crc32(source) % 5) + 1}" : "", ".cloudinary.com"].join
    prefix = "http://#{host}"
  end
  prefix += "/#{cloud_name}" if shared_domain

  prefix
end

.zip_download_url(tag, options = {}) ⇒ Object

Deprecated.

Replaced by download_zip_url that uses the more advanced and robust archive generation and download API

Utility method that uses the deprecated ZIP download API.



496
497
498
499
500
 
# File 'lib/cloudinary/utils.rb', line 496

def self.zip_download_url(tag, options = {})
  warn "zip_download_url is deprecated. Please use download_zip_url instead."
  cloudinary_params = sign_request({:timestamp=>Time.now.to_i, :tag=>tag, :transformation=>generate_transformation_string(options)}, options)
  return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + hash_query_params(cloudinary_params)
end