cloudinary 1.11.1 → 1.18.0

data/lib/cloudinary/railtie.rb

@@ -1,8 +1,12 @@
 class Cloudinary::Railtie < Rails::Railtie
   rake_tasks do
-    Dir[File.join(File.dirname(__FILE__),'../tasks/*.rake')].each { |f| load f }
-  end  
+    Dir[File.join(File.dirname(__FILE__),'../tasks/**/*.rake')].each { |f| load f }
+  end
   config.after_initialize do |app|
     ActionView::Base.send :include, CloudinaryHelper
   end
-end
+
+  ActiveSupport.on_load(:action_controller_base) do
+    ActionController::Base.send :include, Cloudinary::CloudinaryController
+  end
+end

data/lib/cloudinary/uploader.rb

@@ -5,8 +5,7 @@ require 'cloudinary/cache'
 
 class Cloudinary::Uploader
 
-  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$)
-
+  REMOTE_URL_REGEX = Cloudinary::Utils::REMOTE_URL_REGEX
   # @deprecated use {Cloudinary::Utils.build_eager} instead
   def self.build_eager(eager)
     Cloudinary::Utils.build_eager(eager)
@@ -28,6 +27,7 @@ class Cloudinary::Uploader
       :backup                    => Cloudinary::Utils.as_safe_bool(options[:backup]),
       :callback                  => options[:callback],
       :categorization            => options[:categorization],
+      :cinemagraph_analysis      => Cloudinary::Utils.as_safe_bool(options[:cinemagraph_analysis]),
       :colors                    => Cloudinary::Utils.as_safe_bool(options[:colors]),
       :context                   => Cloudinary::Utils.encode_context(options[:context]),
       :custom_coordinates        => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
@@ -37,6 +37,7 @@ class Cloudinary::Uploader
       :eager_async               => Cloudinary::Utils.as_safe_bool(options[:eager_async]),
       :eager_notification_url    => options[:eager_notification_url],
       :exif                      => Cloudinary::Utils.as_safe_bool(options[:exif]),
+      :eval                      => options[:eval],
       :face_coordinates          => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
       :faces                     => Cloudinary::Utils.as_safe_bool(options[:faces]),
       :folder                    => options[:folder],
@@ -64,6 +65,8 @@ class Cloudinary::Uploader
       :unique_filename           => Cloudinary::Utils.as_safe_bool(options[:unique_filename]),
       :upload_preset             => options[:upload_preset],
       :use_filename              => Cloudinary::Utils.as_safe_bool(options[:use_filename]),
+      :accessibility_analysis    => Cloudinary::Utils.as_safe_bool(options[:accessibility_analysis]),
+      :metadata                  => Cloudinary::Utils.encode_context(options[:metadata])
     }
     params
   end
@@ -77,7 +80,10 @@ class Cloudinary::Uploader
       params = build_upload_params(options)
       if file.is_a?(Pathname)
         params[:file] = File.open(file, "rb")
-      elsif file.respond_to?(:read) || file.match(REMOTE_URL_REGEX)
+      elsif file.is_a?(StringIO)
+        file.rewind
+        params[:file] = Cloudinary::Blob.new(file.read, options)
+      elsif file.respond_to?(:read) || Cloudinary::Utils.is_remote?(file)
         params[:file] = file
       else
         params[:file] = File.open(file, "rb")
@@ -95,7 +101,7 @@ class Cloudinary::Uploader
       public_id = public_id_or_options
       options   = old_options
     end
-    if file.match(REMOTE_URL_REGEX)
+    if Cloudinary::Utils.is_remote?(file)
       return upload(file, options.merge(:public_id => public_id))
     elsif file.is_a?(Pathname) || !file.respond_to?(:read)
       filename = file
@@ -248,7 +254,7 @@ class Cloudinary::Uploader
     end
   end
 
-  # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources 
+  # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources
   def self.add_tag(tag, public_ids = [], options = {})
     exclusive = options.delete(:exclusive)
     command   = exclusive ? "set_exclusive" : "add"
@@ -267,6 +273,29 @@ class Cloudinary::Uploader
     return self.call_tags_api(nil, "remove_all", public_ids, options)
   end
 
+  # Populates metadata fields with the given values. Existing values will be overwritten.
+  #
+  # Any metadata-value pairs given are merged with any existing metadata-value pairs
+  # (an empty value for an existing metadata field clears the value).
+  #
+  # @param [Hash] metadata    A list of custom metadata fields (by external_id) and the values to assign to each of them.
+  # @param [Array] public_ids An array of Public IDs of assets uploaded to Cloudinary.
+  # @param [Hash] options
+  # @option options [String] :resource_type The type of file. Default: image. Valid values: image, raw, video.
+  # @option options [String] :type          The storage type. Default: upload. Valid values: upload, private, authenticated
+  # @return mixed a list of public IDs that were updated
+  # @raise [Cloudinary::Api:Error]
+  def self.update_metadata(metadata, public_ids, options = {})
+    self.call_api("metadata", options) do
+      {
+        timestamp: (options[:timestamp] || Time.now.to_i),
+        type: options[:type],
+        public_ids: Cloudinary::Utils.build_array(public_ids),
+        metadata: Cloudinary::Utils.encode_context(metadata)
+      }
+    end
+  end
+
   private
 
   def self.call_tags_api(tag, command, public_ids = [], options = {})
@@ -317,7 +346,7 @@ class Cloudinary::Uploader
       params[:signature] = Cloudinary::Utils.api_sign_request(params.reject { |k, v| non_signable.include?(k) }, api_secret)
       params[:api_key]   = api_key
     end
-    timeout = options[:timeout] || Cloudinary.config.timeout || 60
+    timeout = options.fetch(:timeout) { Cloudinary.config.to_h.fetch(:timeout, 60) }
 
     result = nil
 

data/lib/cloudinary/utils.rb

@@ -1,4 +1,6 @@
 # Copyright Cloudinary
+
+# frozen_string_literal: true
 require 'digest/sha1'
 require 'zlib'
 require 'uri'
@@ -24,7 +26,8 @@ class Cloudinary::Utils
     "*" => 'mul',
     "/" => 'div',
     "+" => 'add',
-    "-" => 'sub'
+    "-" => 'sub',
+    "^" => 'pow'
   }
 
   PREDEFINED_VARS = {
@@ -39,9 +42,32 @@ class Cloudinary::Utils
     "page_x"               => "px",
     "page_y"               => "py",
     "tags"                 => "tags",
+    "initial_duration"     => "idu",
+    "duration"             => "du",
     "width"                => "w"
   }
 
+  SIMPLE_TRANSFORMATION_PARAMS = {
+    :ac => :audio_codec,
+    :af => :audio_frequency,
+    :br => :bit_rate,
+    :cs => :color_space,
+    :d  => :default_image,
+    :dl => :delay,
+    :dn => :density,
+    :du => :duration,
+    :eo => :end_offset,
+    :f  => :fetch_format,
+    :g  => :gravity,
+    :ki => :keyframe_interval,
+    :p  => :prefix,
+    :pg => :page,
+    :so => :start_offset,
+    :sp => :streaming_profile,
+    :vc => :video_codec,
+    :vs => :video_sampling
+  }.freeze
+
   URL_KEYS = %w[
       api_secret
       auth_token
@@ -113,6 +139,11 @@ class Cloudinary::Utils
       zoom
   ].map(&:to_sym)
 
+  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^gs:|^data:([\w-]+\/[\w-]+(\+[\w-]+)?)?(;[\w-]+=[\w-]+)*;base64,([a-zA-Z0-9\/+\n=]+)$)
+
+  LONG_URL_SIGNATURE_LENGTH = 32
+  SHORT_URL_SIGNATURE_LENGTH = 8
+
   def self.extract_config_params(options)
       options.select{|k,v| URL_KEYS.include?(k)}
   end
@@ -216,7 +247,7 @@ class Cloudinary::Utils
       :l  => overlay,
       :o => normalize_expression(options.delete(:opacity)),
       :q => normalize_expression(options.delete(:quality)),
-      :r => normalize_expression(options.delete(:radius)),
+      :r => process_radius(options.delete(:radius)),
       :t   => named_transformation,
       :u  => underlay,
       :w   => normalize_expression(width),
@@ -224,26 +255,7 @@ class Cloudinary::Utils
       :y => normalize_expression(options.delete(:y)),
       :z => normalize_expression(options.delete(:zoom))
     }
-    {
-      :ac => :audio_codec,
-      :af => :audio_frequency,
-      :br => :bit_rate,
-      :cs => :color_space,
-      :d  => :default_image,
-      :dl => :delay,
-      :dn => :density,
-      :du => :duration,
-      :eo => :end_offset,
-      :f  => :fetch_format,
-      :g  => :gravity,
-      :ki => :keyframe_interval,
-      :p  => :prefix,
-      :pg => :page,
-      :so => :start_offset,
-      :sp => :streaming_profile,
-      :vc => :video_codec,
-      :vs => :video_sampling
-    }.each do
+    SIMPLE_TRANSFORMATION_PARAMS.each do
       |param, option|
       params[param] = options.delete(option)
     end
@@ -293,19 +305,17 @@ class Cloudinary::Utils
   # Translates the condition if provided.
   # @return [string] "if_" + ifValue
   # @private
-  def self.process_if(ifValue)
-    if ifValue
-      ifValue = normalize_expression(ifValue)
-
-      ifValue = "if_" + ifValue
-    end
+  def self.process_if(if_value)
+    "if_" + normalize_expression(if_value) unless if_value.to_s.empty?
   end
 
-  EXP_REGEXP = Regexp.new(PREDEFINED_VARS.keys.join("|")+'|('+CONDITIONAL_OPERATORS.keys.reverse.map { |k| Regexp.escape(k) }.join('|')+')(?=[ _])')
+  EXP_REGEXP = Regexp.new('(?<!\$)('+PREDEFINED_VARS.keys.join("|")+')'+'|('+CONDITIONAL_OPERATORS.keys.reverse.map { |k| Regexp.escape(k) }.join('|')+')(?=[ _])')
   EXP_REPLACEMENT = PREDEFINED_VARS.merge(CONDITIONAL_OPERATORS)
 
   def self.normalize_expression(expression)
-    if expression =~ /^!.+!$/ # quoted string
+    if expression.nil?
+      ''
+    elsif expression.is_a?( String) && expression =~ /^!.+!$/ # quoted string
       expression
     else
       expression.to_s.gsub(EXP_REGEXP,EXP_REPLACEMENT).gsub(/[ _]+/, "_")
@@ -375,6 +385,17 @@ class Cloudinary::Utils
   end
   private_class_method :process_layer
 
+  # Parse radius options
+  # @return [string] radius transformation string
+  # @private
+  def self.process_radius(radius)
+    if radius.is_a?(Array) && !radius.length.between?(1, 4)
+      raise(CloudinaryException, "Invalid radius parameter")
+    end
+    Array(radius).map { |r| normalize_expression(r) }.join(":")
+  end
+  private_class_method :process_radius
+
   LAYER_KEYWORD_PARAMS =[
     [:font_weight     ,"normal"],
     [:font_style      ,"normal"],
@@ -395,6 +416,10 @@ class Cloudinary::Utils
     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?
+    font_antialiasing = layer[:font_antialiasing]
+    keywords.push("antialias_#{font_antialiasing}") unless font_antialiasing.blank?
+    font_hinting = layer[:font_hinting]
+    keywords.push("hinting_#{font_hinting}") unless font_hinting.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?
@@ -455,6 +480,7 @@ class Cloudinary::Utils
 
     resource_type = options.delete(:resource_type)
     version = options.delete(:version)
+    force_version = config_option_consume(options, :force_version, true)
     format = options.delete(:format)
     cloud_name = config_option_consume(options, :cloud_name) || raise(CloudinaryException, "Must supply cloud_name in tag or in configuration")
 
@@ -474,6 +500,7 @@ class Cloudinary::Utils
     url_suffix = options.delete(:url_suffix)
     use_root_path = config_option_consume(options, :use_root_path)
     auth_token = config_option_consume(options, :auth_token)
+    long_url_signature = config_option_consume(options, :long_url_signature)
     unless auth_token == false
       auth_token = Cloudinary::AuthToken.merge_auth_token(Cloudinary.config.auth_token, auth_token)
     end
@@ -505,7 +532,12 @@ class Cloudinary::Utils
     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?:\//)
+    if version.nil? && force_version &&
+         source_to_sign.include?("/") &&
+         !source_to_sign.match(/^v[0-9]+/) &&
+         !source_to_sign.match(/^https?:\//)
+      version = 1
+    end
     version &&= "v#{version}"
 
     transformation = transformation.gsub(%r(([^:])//), '\1/')
@@ -513,7 +545,7 @@ class Cloudinary::Utils
       raise(CloudinaryException, "Must supply api_secret") if (secret.nil? || secret.empty?)
       to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
       to_sign = fully_unescape(to_sign)
-      signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
+      signature = compute_signature(to_sign, secret, long_url_signature)
     end
 
     prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
@@ -533,7 +565,7 @@ class Cloudinary::Utils
       source = smart_escape(source)
       source_to_sign = source
     else
-      source = smart_escape(URI.decode(source))
+      source = smart_escape(smart_unescape(source))
       source_to_sign = source
       unless url_suffix.blank?
         raise(CloudinaryException, "url_suffix should not include . or /") if url_suffix.match(%r([\./]))
@@ -704,6 +736,18 @@ class Cloudinary::Utils
     download_archive_url(options.merge(:target_format => "zip"))
   end
 
+  # Creates and returns a URL that when invoked creates an archive of a folder.
+  #
+  # @param [Object] folder_path Full path (from the root) of the folder to download.
+  # @param [Hash] options       Additional options.
+  #
+  # @return [String]
+  def self.download_folder(folder_path, options = {})
+    resource_type = options[:resource_type] || "all"
+
+    download_archive_url(options.merge(:resource_type => resource_type, :prefixes => folder_path))
+  end
+
   def self.signed_download_url(public_id, options = {})
     aws_private_key_path = options[:aws_private_key_path] || Cloudinary.config.aws_private_key_path
     if aws_private_key_path
@@ -737,13 +781,18 @@ class Cloudinary::Utils
     "#{public_id}#{ext}"
   end
 
-  # Based on CGI::unescape. In addition does not escape / :
+  # Based on CGI::escape. In addition does not escape / :
   def self.smart_escape(string, unsafe = /([^a-zA-Z0-9_.\-\/:]+)/)
     string.gsub(unsafe) do |m|
       '%' + m.unpack('H2' * m.bytesize).join('%').upcase
     end
   end
 
+  # Based on CGI::unescape. In addition keeps '+' character as is
+  def self.smart_unescape(string)
+    CGI.unescape(string.sub('+', '%2B'))
+  end
+
   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]
@@ -811,7 +860,7 @@ class Cloudinary::Utils
     end
   end
 
-  IMAGE_FORMATS = %w(ai bmp bpg djvu eps eps3 flif gif hdp hpx ico j2k jp2 jpc jpe jpg miff pdf png psd svg tif tiff wdp webp zip )
+  IMAGE_FORMATS = %w(ai bmp bpg djvu eps eps3 flif gif hdp hpx ico j2k jp2 jpc jpe jpeg jpg miff pdf png psd svg tif tiff wdp webp zip )
 
   AUDIO_FORMATS = %w(aac aifc aiff flac m4a mp3 ogg wav)
 
@@ -831,10 +880,8 @@ class Cloudinary::Utils
     case
     when self.supported_format?(format, IMAGE_FORMATS)
       'image'
-    when self.supported_format?(format, VIDEO_FORMATS)
+    when self.supported_format?(format, VIDEO_FORMATS), self.supported_format?(format, AUDIO_FORMATS)
       'video'
-    when self.supported_format?(format, AUDIO_FORMATS)
-      'audio'
     else
       'raw'
     end
@@ -842,7 +889,8 @@ class Cloudinary::Utils
 
   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
+    option_value = Cloudinary.config.send(option_name)
+    option_value.nil? ? default_value : option_value
   end
 
   def self.as_bool(value)
@@ -851,7 +899,7 @@ class Cloudinary::Utils
     when String then value.downcase == "true" || value == "1"
     when TrueClass then true
     when FalseClass then false
-    when Fixnum then value != 0
+    when Integer then value != 0
     when Symbol then value == :true
     else
       raise "Invalid boolean value #{value} of type #{value.class}"
@@ -928,6 +976,7 @@ class Cloudinary::Utils
       :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]),
+      :fully_qualified_public_ids=>options[:fully_qualified_public_ids] && Cloudinary::Utils.build_array(options[:fully_qualified_public_ids]),
       :prefixes=>options[:prefixes] && Cloudinary::Utils.build_array(options[:prefixes]),
       :expires_at=>options[:expires_at],
       :transformations => build_eager(options[:transformations]),
@@ -1096,4 +1145,27 @@ class Cloudinary::Utils
     end
   end
 
+  def self.is_remote?(url)
+    REMOTE_URL_REGEX === url
+  end
+
+  # Computes a short or long signature based on a message and secret
+  # @param [String]  message The string to sign
+  # @param [String]  secret A secret that will be added to the message when signing
+  # @param [Boolean] long_signature Whether to create a short or long signature
+  # @return [String] Properly formatted signature
+  def self.compute_signature(message, secret, long_url_signature)
+    combined_message_secret = message + secret
+
+    algo, signature_length =
+      if long_url_signature
+        [Digest::SHA256, LONG_URL_SIGNATURE_LENGTH]
+      else
+        [Digest::SHA1, SHORT_URL_SIGNATURE_LENGTH]
+      end
+
+    "s--#{Base64.urlsafe_encode64(algo.digest(combined_message_secret))[0, signature_length]}--"
+  end
+
+  private_class_method :compute_signature
 end

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.11.1"
+  VERSION = "1.18.0"
 end

data/lib/cloudinary/video_helper.rb

@@ -3,12 +3,33 @@ module CloudinaryHelper
   DEFAULT_POSTER_OPTIONS = { :format => 'jpg', :resource_type => 'video' }
   DEFAULT_SOURCE_TYPES   = %w(webm mp4 ogv)
   DEFAULT_VIDEO_OPTIONS  = { :resource_type => 'video' }
+  DEFAULT_SOURCES        = [
+    {
+      :type            => "mp4",
+      :codecs          => "hev1",
+      :transformations => { :video_codec => "h265" }
+    },
+    {
+      :type            => "webm",
+      :codecs          => "vp9",
+      :transformations => { :video_codec => "vp9" }
+    },
+    {
+      :type            => "mp4",
+      :transformations => { :video_codec => "auto" }
+    },
+    {
+      :type            => "webm",
+      :transformations => { :video_codec => "auto" }
+    }
+  ]
 
   # Creates an HTML video tag for the provided +source+
   #
   # ==== Options
   # * <tt>:source_types</tt> - Specify which source type the tag should include. defaults to webm, mp4 and ogv.
   # * <tt>:source_transformation</tt> - specific transformations to use for a specific source type.
+  # * <tt>:sources</tt> - list of sources (overrides :source_types when present)
   # * <tt>:poster</tt> - override default thumbnail:
   #   * url: provide an ad hoc url
   #   * options: with specific poster transformations and/or Cloudinary +:public_id+
@@ -20,6 +41,17 @@ module CloudinaryHelper
   #   cl_video_tag("mymovie.webm", :source_types => [:webm, :mp4], :poster => {:effect => 'sepia'}) do
   #     content_tag( :span, "Cannot present video!")
   #   end
+  #   cl_video_tag("mymovie", :sources => [
+  #     {
+  #       :type => "mp4",
+  #       :codecs => "hev1",
+  #       :transformations => { :video_codec => "h265" }
+  #     },
+  #     {
+  #       :type => "webm",
+  #       :transformations => { :video_codec => "auto" }
+  #     }
+  #   ])
   def cl_video_tag(source, options = {}, &block)
     source = strip_known_ext(source)
     video_attributes = [:autoplay,:controls,:loop,:muted,:poster, :preload]
@@ -48,30 +80,12 @@ module CloudinaryHelper
       video_options[:poster] = cl_video_thumbnail_path(source, options)
     end
 
-    source_transformation = options.delete(:source_transformation) || {}
-    source_types = Array(options.delete(:source_types))
-    fallback     = (capture(&block) if block_given?) || options.delete(:fallback_content)
+    fallback = (capture(&block) if block_given?) || options.delete(:fallback_content)
 
-    if source_types.size > 1
-      cloudinary_tag(source, options) do |_source, tag_options|
-        content_tag('video', tag_options.merge(video_options)) do
-          source_tags = source_types.map do |type|
-            transformation = source_transformation[type.to_sym] || {}
-            cloudinary_tag("#{source}.#{type}", options.merge(transformation)) do |url, _tag_options|
-              mime_type = "video/#{(type == 'ogv' ? 'ogg' : type)}"
-              tag("source", :src => url, :type => mime_type)
-            end
-          end
-          source_tags.push(fallback.html_safe) unless fallback.blank?
-          safe_join(source_tags)
-        end
-      end
+    if options[:sources]
+      video_tag_from_sources(source, options, video_options, fallback)
     else
-      transformation      = source_transformation[source_types.first.to_sym] || {}
-      video_options[:src] = cl_video_path("#{source}.#{source_types.first.to_sym}", transformation.merge(options))
-      cloudinary_tag(source, options) do |_source, tag_options|
-        content_tag('video', fallback, tag_options.merge(video_options))
-      end
+      video_tag_from_source_types(source, options, video_options, fallback)
     end
   end
 
@@ -96,6 +110,66 @@ module CloudinaryHelper
     name.sub(/\.(#{DEFAULT_SOURCE_TYPES.join("|")})$/, '')
   end
 
+  private
+
+  def video_tag_from_source_types(source_name, options, video_options, fallback)
+    source_transformation = options.delete(:source_transformation) || {}
+    source_types = Array(options.delete(:source_types))
+
+    if source_types.size > 1
+      sources = source_types.map do |type|
+        {
+          :type => type,
+          :transformations => source_transformation[type.to_sym] || {}
+        }
+      end
+
+      generate_tag_from_sources(:source_name => source_name,
+                                :sources => sources,
+                                :options => options,
+                                :video_options => video_options,
+                                :fallback => fallback)
+    else
+      transformation      = source_transformation[source_types.first.to_sym] || {}
+      video_options[:src] = cl_video_path("#{source_name}.#{source_types.first.to_sym}", transformation.merge(options))
+      cloudinary_tag(source_name, options) do |_source, tag_options|
+        content_tag('video', fallback, tag_options.merge(video_options))
+      end
+    end
+  end
+
+  def video_tag_from_sources(source_name, options, video_options, fallback)
+    sources = options.delete(:sources)
+
+    generate_tag_from_sources(:source_name => source_name,
+                              :sources => sources,
+                              :options => options,
+                              :video_options => video_options,
+                              :fallback => fallback)
+  end
+
+  def generate_tag_from_sources(params)
+    source_name, sources, options, video_options, fallback = params.values_at(:source_name, :sources, :options, :video_options, :fallback)
+
+    cloudinary_tag(source_name, options) do |_source, tag_options|
+      content_tag('video', tag_options.merge(video_options)) do
+        source_tags = sources.map do |source|
+          type = source[:type]
+          transformation = source[:transformations] || {}
+          cloudinary_tag("#{source_name}.#{type}", options.merge(transformation)) do |url, _tag_options|
+            mime_type = "video/#{(type == 'ogv' ? 'ogg' : type)}"
+            if source[:codecs]
+              codecs = source[:codecs].is_a?(Array) ? source[:codecs].join(", ") : source[:codecs]
+              mime_type = "#{mime_type}; codecs=#{codecs}"
+            end
+            tag("source", :src => url, :type => mime_type)
+          end
+        end
+        source_tags.push(fallback.html_safe) unless fallback.blank?
+        safe_join(source_tags)
+      end
+    end
+  end
 end