cloudinary 1.0.69 → 1.0.70

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/CHANGELOG CHANGED
@@ -1,3 +1,10 @@
1
+ = Version 1.0.70 - 2014-03-25
2
+ * Support upload_large without public_id.
3
+ * Remove public_id from method parameters.
4
+ * Backward compatibility for old upload_large API.
5
+ * Issue #95 - exception when using storage_type :private
6
+ * Updating to jQuery plugin v1.0.13.
7
+
1
8
  = Version 1.0.69 - 2014-02-25
2
9
  * Admin API update method.
3
10
  * Admin API listing by moderation kind and status.
@@ -6,7 +6,7 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
6
6
  case file
7
7
  when Cloudinary::CarrierWave::PreloadedCloudinaryFile
8
8
  storage_type = uploader.class.storage_type || "upload"
9
- raise CloudinaryException, "Uploader configured for type #{storage_type} but resource of type #{file.type} given." if storage_type != file.type
9
+ raise CloudinaryException, "Uploader configured for type #{storage_type} but resource of type #{file.type} given." if storage_type.to_s != file.type
10
10
  if uploader.public_id && uploader.auto_rename_preloaded?
11
11
  @stored_version = file.version
12
12
  uploader.rename(nil, true)
@@ -1,82 +1,93 @@
1
- # Copyright Cloudinary
2
- require 'rest_client'
3
- require 'json'
4
-
5
- class Cloudinary::Uploader
6
-
7
- def self.build_eager(eager)
8
- return nil if eager.nil?
9
- Cloudinary::Utils.build_array(eager).map do
10
- |transformation, format|
11
- transformation = transformation.clone
12
- format = transformation.delete(:format) || format
13
- [Cloudinary::Utils.generate_transformation_string(transformation), format].compact.join("/")
14
- end.join("|")
15
- end
16
-
17
- def self.build_upload_params(options)
18
- params = {:timestamp=>Time.now.to_i,
19
- :transformation => Cloudinary::Utils.generate_transformation_string(options.clone),
20
- :public_id=> options[:public_id],
21
- :callback=> options[:callback],
22
- :format=>options[:format],
23
- :type=>options[:type],
24
- :backup=>Cloudinary::Utils.as_safe_bool(options[:backup]),
25
- :faces=>Cloudinary::Utils.as_safe_bool(options[:faces]),
26
- :exif=>Cloudinary::Utils.as_safe_bool(options[:exif]),
27
- :colors=>Cloudinary::Utils.as_safe_bool(options[:colors]),
28
- :image_metadata=>Cloudinary::Utils.as_safe_bool(options[:image_metadata]),
29
- :invalidate=>Cloudinary::Utils.as_safe_bool(options[:invalidate]),
30
- :eager=>build_eager(options[:eager]),
31
- :headers=>build_custom_headers(options[:headers]),
32
- :use_filename=>Cloudinary::Utils.as_safe_bool(options[:use_filename]),
33
- :unique_filename=>Cloudinary::Utils.as_safe_bool(options[:unique_filename]),
34
- :overwrite=>Cloudinary::Utils.as_safe_bool(options[:overwrite]),
35
- :discard_original_filename=>Cloudinary::Utils.as_safe_bool(options[:discard_original_filename]),
36
- :notification_url=>options[:notification_url],
37
- :eager_notification_url=>options[:eager_notification_url],
38
- :eager_async=>Cloudinary::Utils.as_safe_bool(options[:eager_async]),
39
- :proxy=>options[:proxy],
40
- :folder=>options[:folder],
1
+ # Copyright Cloudinary
2
+ require 'rest_client'
3
+ require 'json'
4
+
5
+ class Cloudinary::Uploader
6
+
7
+ def self.build_eager(eager)
8
+ return nil if eager.nil?
9
+ Cloudinary::Utils.build_array(eager).map do
10
+ |transformation, format|
11
+ transformation = transformation.clone
12
+ format = transformation.delete(:format) || format
13
+ [Cloudinary::Utils.generate_transformation_string(transformation), format].compact.join("/")
14
+ end.join("|")
15
+ end
16
+
17
+ def self.build_upload_params(options)
18
+ params = {:timestamp=>Time.now.to_i,
19
+ :transformation => Cloudinary::Utils.generate_transformation_string(options.clone),
20
+ :public_id=> options[:public_id],
21
+ :callback=> options[:callback],
22
+ :format=>options[:format],
23
+ :type=>options[:type],
24
+ :backup=>Cloudinary::Utils.as_safe_bool(options[:backup]),
25
+ :faces=>Cloudinary::Utils.as_safe_bool(options[:faces]),
26
+ :exif=>Cloudinary::Utils.as_safe_bool(options[:exif]),
27
+ :colors=>Cloudinary::Utils.as_safe_bool(options[:colors]),
28
+ :image_metadata=>Cloudinary::Utils.as_safe_bool(options[:image_metadata]),
29
+ :invalidate=>Cloudinary::Utils.as_safe_bool(options[:invalidate]),
30
+ :eager=>build_eager(options[:eager]),
31
+ :headers=>build_custom_headers(options[:headers]),
32
+ :use_filename=>Cloudinary::Utils.as_safe_bool(options[:use_filename]),
33
+ :unique_filename=>Cloudinary::Utils.as_safe_bool(options[:unique_filename]),
34
+ :overwrite=>Cloudinary::Utils.as_safe_bool(options[:overwrite]),
35
+ :discard_original_filename=>Cloudinary::Utils.as_safe_bool(options[:discard_original_filename]),
36
+ :notification_url=>options[:notification_url],
37
+ :eager_notification_url=>options[:eager_notification_url],
38
+ :eager_async=>Cloudinary::Utils.as_safe_bool(options[:eager_async]),
39
+ :proxy=>options[:proxy],
40
+ :folder=>options[:folder],
41
41
  :allowed_formats => Cloudinary::Utils.build_array(options[:allowed_formats]).join(","),
42
- :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
43
- :context => Cloudinary::Utils.encode_hash(options[:context]),
44
- :face_coordinates => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
45
- :moderation => options[:moderation],
46
- :raw_convert => options[:raw_convert],
47
- :ocr => options[:ocr],
48
- :categorization => options[:categorization],
42
+ :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
43
+ :context => Cloudinary::Utils.encode_hash(options[:context]),
44
+ :face_coordinates => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
45
+ :moderation => options[:moderation],
46
+ :raw_convert => options[:raw_convert],
47
+ :ocr => options[:ocr],
48
+ :categorization => options[:categorization],
49
49
  :detection => options[:detection],
50
50
  :similarity_search => options[:similarity_search],
51
- :auto_tagging => options[:auto_tagging] && options[:auto_tagging].to_f}
52
- params
53
- end
54
-
55
- def self.upload(file, options={})
56
- call_api("upload", options) do
57
- params = build_upload_params(options)
58
- if file.is_a?(Pathname)
59
- params[:file] = File.open(file, "rb")
60
- elsif file.respond_to?(:read) || file =~ /^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$/
61
- params[:file] = file
62
- else
63
- params[:file] = File.open(file, "rb")
64
- end
65
- [params, [:file]]
66
- end
67
- end
68
-
51
+ :auto_tagging => options[:auto_tagging] && options[:auto_tagging].to_f}
52
+ params
53
+ end
54
+
55
+ def self.upload(file, options={})
56
+ call_api("upload", options) do
57
+ params = build_upload_params(options)
58
+ if file.is_a?(Pathname)
59
+ params[:file] = File.open(file, "rb")
60
+ elsif file.respond_to?(:read) || file =~ /^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$/
61
+ params[:file] = file
62
+ else
63
+ params[:file] = File.open(file, "rb")
64
+ end
65
+ [params, [:file]]
66
+ end
67
+ end
68
+
69
69
  # Upload large raw files. Note that public_id should include an extension for best results.
70
- def self.upload_large(file, public_id, options={})
70
+ def self.upload_large(file, public_id_or_options={}, old_options={})
71
+ if public_id_or_options.is_a?(Hash)
72
+ options = public_id_or_options
73
+ public_id = options[:public_id]
74
+ else
75
+ public_id = public_id_or_options
76
+ options = old_options
77
+ end
71
78
  if file.is_a?(Pathname) || !file.respond_to?(:read)
79
+ filename = file
72
80
  file = File.open(file, "rb")
81
+ else
82
+ filename = "cloudinaryfile"
73
83
  end
74
84
  upload = upload_id = nil
75
85
  index = 1
76
86
  while !file.eof?
77
87
  buffer = file.read(20_000_000)
78
- upload = upload_large_part(Cloudinary::Blob.new(buffer), public_id, options.merge(:upload_id=>upload_id, :part_number=>index, :final=>file.eof?))
79
- upload_id = upload["upload_id"]
88
+ upload = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename=>filename), options.merge(:public_id=>public_id, :upload_id=>upload_id, :part_number=>index, :final=>file.eof?))
89
+ upload_id = upload["upload_id"]
90
+ public_id = upload["public_id"]
80
91
  index += 1
81
92
  end
82
93
  upload
@@ -84,12 +95,12 @@ class Cloudinary::Uploader
84
95
 
85
96
 
86
97
  # Upload large raw files. Note that public_id should include an extension for best results.
87
- def self.upload_large_part(file, public_id, options={})
98
+ def self.upload_large_part(file, options={})
88
99
  call_api("upload_large", options.merge(:resource_type=>:raw)) do
89
100
  params = {
90
101
  :timestamp=>Time.now.to_i,
91
102
  :type=>options[:type],
92
- :public_id=> public_id,
103
+ :public_id=>options[:public_id],
93
104
  :backup=>options[:backup],
94
105
  :final=>options[:final],
95
106
  :part_number=>options[:part_number],
@@ -103,179 +114,179 @@ class Cloudinary::Uploader
103
114
  [params, [:file]]
104
115
  end
105
116
  end
117
+
118
+ def self.destroy(public_id, options={})
119
+ call_api("destroy", options) do
120
+ {
121
+ :timestamp=>Time.now.to_i,
122
+ :type=>options[:type],
123
+ :public_id=> public_id,
124
+ :invalidate=>options[:invalidate],
125
+ }
126
+ end
127
+ end
128
+
129
+ def self.rename(from_public_id, to_public_id, options={})
130
+ call_api("rename", options) do
131
+ {
132
+ :timestamp=>Time.now.to_i,
133
+ :type=>options[:type],
134
+ :overwrite=>options[:overwrite],
135
+ :from_public_id=>from_public_id,
136
+ :to_public_id=>to_public_id,
137
+ }
138
+ end
139
+ end
140
+
141
+ def self.exists?(public_id, options={})
142
+ cloudinary_url = Cloudinary::Utils.cloudinary_url(public_id, options)
143
+ begin
144
+ RestClient::Request.execute(:method => :head, :url => cloudinary_url, :timeout=>5).code.to_s =~ /2\d{2}/
145
+ rescue RestClient::ResourceNotFound => e
146
+ return false
147
+ end
148
+
149
+ end
150
+
151
+ def self.explicit(public_id, options={})
152
+ call_api("explicit", options) do
153
+ {
154
+ :timestamp=>Time.now.to_i,
155
+ :type=>options[:type],
156
+ :public_id=> public_id,
157
+ :callback=> options[:callback],
158
+ :eager=>build_eager(options[:eager]),
159
+ :headers=>build_custom_headers(options[:headers]),
160
+ :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
161
+ :face_coordinates => options[:face_coordinates] && Cloudinary::Utils.encode_double_array(options[:face_coordinates])
162
+ }
163
+ end
164
+ end
165
+
166
+ TEXT_PARAMS = [:public_id, :font_family, :font_size, :font_color, :text_align, :font_weight, :font_style, :background, :opacity, :text_decoration, :line_spacing]
167
+ def self.text(text, options={})
168
+ call_api("text", options) do
169
+ params = {:timestamp => Time.now.to_i, :text=>text}
170
+ TEXT_PARAMS.each{|k| params[k] = options[k] if !options[k].nil?}
171
+ params
172
+ end
173
+ end
174
+
175
+ def self.generate_sprite(tag, options={})
176
+ version_store = options.delete(:version_store)
177
+
178
+ result = call_api("sprite", options) do
179
+ {
180
+ :timestamp=>Time.now.to_i,
181
+ :tag=>tag,
182
+ :async=>options[:async],
183
+ :notification_url=>options[:notification_url],
184
+ :transformation => Cloudinary::Utils.generate_transformation_string(options.merge(:fetch_format=>options[:format]))
185
+ }
186
+ end
187
+
188
+ if version_store == :file && result && result["version"]
189
+ if defined?(Rails) && defined?(Rails.root)
190
+ FileUtils.mkdir_p("#{Rails.root}/tmp/cloudinary")
191
+ File.open("#{Rails.root}/tmp/cloudinary/cloudinary_sprite_#{tag}.version", "w"){|file| file.print result["version"].to_s}
192
+ end
193
+ end
194
+ return result
195
+ end
196
+
197
+ def self.multi(tag, options={})
198
+ call_api("multi", options) do
199
+ {
200
+ :timestamp=>Time.now.to_i,
201
+ :tag=>tag,
202
+ :format=>options[:format],
203
+ :async=>options[:async],
204
+ :notification_url=>options[:notification_url],
205
+ :transformation => Cloudinary::Utils.generate_transformation_string(options.clone)
206
+ }
207
+ end
208
+ end
106
209
 
107
- def self.destroy(public_id, options={})
108
- call_api("destroy", options) do
109
- {
110
- :timestamp=>Time.now.to_i,
111
- :type=>options[:type],
112
- :public_id=> public_id,
113
- :invalidate=>options[:invalidate],
114
- }
115
- end
116
- end
117
-
118
- def self.rename(from_public_id, to_public_id, options={})
119
- call_api("rename", options) do
120
- {
121
- :timestamp=>Time.now.to_i,
122
- :type=>options[:type],
123
- :overwrite=>options[:overwrite],
124
- :from_public_id=>from_public_id,
125
- :to_public_id=>to_public_id,
126
- }
127
- end
128
- end
129
-
130
- def self.exists?(public_id, options={})
131
- cloudinary_url = Cloudinary::Utils.cloudinary_url(public_id, options)
132
- begin
133
- RestClient::Request.execute(:method => :head, :url => cloudinary_url, :timeout=>5).code.to_s =~ /2\d{2}/
134
- rescue RestClient::ResourceNotFound => e
135
- return false
136
- end
137
-
138
- end
139
-
140
- def self.explicit(public_id, options={})
141
- call_api("explicit", options) do
142
- {
143
- :timestamp=>Time.now.to_i,
144
- :type=>options[:type],
145
- :public_id=> public_id,
146
- :callback=> options[:callback],
147
- :eager=>build_eager(options[:eager]),
148
- :headers=>build_custom_headers(options[:headers]),
149
- :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
150
- :face_coordinates => options[:face_coordinates] && Cloudinary::Utils.encode_double_array(options[:face_coordinates])
151
- }
152
- end
153
- end
154
-
155
- TEXT_PARAMS = [:public_id, :font_family, :font_size, :font_color, :text_align, :font_weight, :font_style, :background, :opacity, :text_decoration, :line_spacing]
156
- def self.text(text, options={})
157
- call_api("text", options) do
158
- params = {:timestamp => Time.now.to_i, :text=>text}
159
- TEXT_PARAMS.each{|k| params[k] = options[k] if !options[k].nil?}
160
- params
161
- end
162
- end
163
-
164
- def self.generate_sprite(tag, options={})
165
- version_store = options.delete(:version_store)
166
-
167
- result = call_api("sprite", options) do
168
- {
169
- :timestamp=>Time.now.to_i,
170
- :tag=>tag,
171
- :async=>options[:async],
172
- :notification_url=>options[:notification_url],
173
- :transformation => Cloudinary::Utils.generate_transformation_string(options.merge(:fetch_format=>options[:format]))
174
- }
175
- end
176
-
177
- if version_store == :file && result && result["version"]
178
- if defined?(Rails) && defined?(Rails.root)
179
- FileUtils.mkdir_p("#{Rails.root}/tmp/cloudinary")
180
- File.open("#{Rails.root}/tmp/cloudinary/cloudinary_sprite_#{tag}.version", "w"){|file| file.print result["version"].to_s}
181
- end
182
- end
183
- return result
184
- end
185
-
186
- def self.multi(tag, options={})
187
- call_api("multi", options) do
188
- {
189
- :timestamp=>Time.now.to_i,
190
- :tag=>tag,
191
- :format=>options[:format],
192
- :async=>options[:async],
193
- :notification_url=>options[:notification_url],
194
- :transformation => Cloudinary::Utils.generate_transformation_string(options.clone)
195
- }
196
- end
197
- end
198
-
199
- def self.explode(public_id, options={})
200
- call_api("explode", options) do
201
- {
202
- :timestamp=>Time.now.to_i,
203
- :public_id=>public_id,
204
- :type=>options[:type],
205
- :format=>options[:format],
206
- :notification_url=>options[:notification_url],
207
- :transformation => Cloudinary::Utils.generate_transformation_string(options.clone)
208
- }
209
- end
210
- end
211
-
212
- # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources
213
- def self.add_tag(tag, public_ids = [], options = {})
214
- exclusive = options.delete(:exclusive)
215
- command = exclusive ? "set_exclusive" : "add"
216
- return self.call_tags_api(tag, command, public_ids, options)
217
- end
218
-
219
- def self.remove_tag(tag, public_ids = [], options = {})
220
- return self.call_tags_api(tag, "remove", public_ids, options)
221
- end
222
-
223
- def self.replace_tag(tag, public_ids = [], options = {})
224
- return self.call_tags_api(tag, "replace", public_ids, options)
225
- end
226
-
227
- private
228
-
229
- def self.call_tags_api(tag, command, public_ids = [], options = {})
230
- return call_api("tags", options) do
231
- {
232
- :timestamp=>Time.now.to_i,
233
- :tag=>tag,
234
- :public_ids => Cloudinary::Utils.build_array(public_ids),
235
- :command => command,
236
- :type => options[:type]
237
- }
238
- end
239
- end
240
-
241
- def self.call_api(action, options)
242
- options = options.clone
243
- return_error = options.delete(:return_error)
244
- api_key = options[:api_key] || Cloudinary.config.api_key || raise(CloudinaryException, "Must supply api_key")
245
- api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise(CloudinaryException, "Must supply api_secret")
246
-
247
- params, non_signable = yield
248
- non_signable ||= []
249
-
250
- params[:signature] = Cloudinary::Utils.api_sign_request(params.reject{|k,v| non_signable.include?(k)}, api_secret)
251
- params[:api_key] = api_key
252
-
253
- result = nil
254
-
255
- api_url = Cloudinary::Utils.cloudinary_api_url(action, options)
256
-
257
- RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject{|k, v| v.nil? || v==""}, :timeout=>60, :headers => {"User-Agent" => Cloudinary::USER_AGENT}) do
258
- |response, request, tmpresult|
259
- raise CloudinaryException, "Server returned unexpected status code - #{response.code} - #{response.body}" if ![200,400,401,403,404,500].include?(response.code)
260
- begin
261
- result = Cloudinary::Utils.json_decode(response.body)
262
- rescue => e
263
- # Error is parsing json
264
- raise CloudinaryException, "Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}"
265
- end
266
- if result["error"]
267
- if return_error
268
- result["error"]["http_code"] = response.code
269
- else
270
- raise CloudinaryException, result["error"]["message"]
271
- end
272
- end
273
- end
274
-
275
- result
276
- end
277
-
278
- def self.build_custom_headers(headers)
279
- Array(headers).map{|*a| a.join(": ")}.join("\n")
280
- end
281
- end
210
+ def self.explode(public_id, options={})
211
+ call_api("explode", options) do
212
+ {
213
+ :timestamp=>Time.now.to_i,
214
+ :public_id=>public_id,
215
+ :type=>options[:type],
216
+ :format=>options[:format],
217
+ :notification_url=>options[:notification_url],
218
+ :transformation => Cloudinary::Utils.generate_transformation_string(options.clone)
219
+ }
220
+ end
221
+ end
222
+
223
+ # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources
224
+ def self.add_tag(tag, public_ids = [], options = {})
225
+ exclusive = options.delete(:exclusive)
226
+ command = exclusive ? "set_exclusive" : "add"
227
+ return self.call_tags_api(tag, command, public_ids, options)
228
+ end
229
+
230
+ def self.remove_tag(tag, public_ids = [], options = {})
231
+ return self.call_tags_api(tag, "remove", public_ids, options)
232
+ end
233
+
234
+ def self.replace_tag(tag, public_ids = [], options = {})
235
+ return self.call_tags_api(tag, "replace", public_ids, options)
236
+ end
237
+
238
+ private
239
+
240
+ def self.call_tags_api(tag, command, public_ids = [], options = {})
241
+ return call_api("tags", options) do
242
+ {
243
+ :timestamp=>Time.now.to_i,
244
+ :tag=>tag,
245
+ :public_ids => Cloudinary::Utils.build_array(public_ids),
246
+ :command => command,
247
+ :type => options[:type]
248
+ }
249
+ end
250
+ end
251
+
252
+ def self.call_api(action, options)
253
+ options = options.clone
254
+ return_error = options.delete(:return_error)
255
+ api_key = options[:api_key] || Cloudinary.config.api_key || raise(CloudinaryException, "Must supply api_key")
256
+ api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise(CloudinaryException, "Must supply api_secret")
257
+
258
+ params, non_signable = yield
259
+ non_signable ||= []
260
+
261
+ params[:signature] = Cloudinary::Utils.api_sign_request(params.reject{|k,v| non_signable.include?(k)}, api_secret)
262
+ params[:api_key] = api_key
263
+
264
+ result = nil
265
+
266
+ api_url = Cloudinary::Utils.cloudinary_api_url(action, options)
267
+
268
+ RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject{|k, v| v.nil? || v==""}, :timeout=>60, :headers => {"User-Agent" => Cloudinary::USER_AGENT}) do
269
+ |response, request, tmpresult|
270
+ raise CloudinaryException, "Server returned unexpected status code - #{response.code} - #{response.body}" if ![200,400,401,403,404,500].include?(response.code)
271
+ begin
272
+ result = Cloudinary::Utils.json_decode(response.body)
273
+ rescue => e
274
+ # Error is parsing json
275
+ raise CloudinaryException, "Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}"
276
+ end
277
+ if result["error"]
278
+ if return_error
279
+ result["error"]["http_code"] = response.code
280
+ else
281
+ raise CloudinaryException, result["error"]["message"]
282
+ end
283
+ end
284
+ end
285
+
286
+ result
287
+ end
288
+
289
+ def self.build_custom_headers(headers)
290
+ Array(headers).map{|*a| a.join(": ")}.join("\n")
291
+ end
292
+ end
@@ -1,4 +1,4 @@
1
1
  # Copyright Cloudinary
2
2
  module Cloudinary
3
- VERSION = "1.0.69"
3
+ VERSION = "1.0.70"
4
4
  end
@@ -133,4 +133,9 @@ describe Cloudinary::Uploader do
133
133
  it "should support requesting auto_tagging" do
134
134
  lambda{Cloudinary::Uploader.upload("spec/logo.png", {:auto_tagging => 0.5})}.should raise_error(CloudinaryException, /Must use/)
135
135
  end
136
+
137
+ it "should support upload_large" do
138
+ result = Cloudinary::Uploader.upload_large("spec/logo.png")
139
+ result["public_id"].should match(/^[a-z0-9]+.png$/)
140
+ end
136
141
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: cloudinary
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.0.69
4
+ version: 1.0.70
5
5
  prerelease:
6
6
  platform: ruby
7
7
  authors:
@@ -11,7 +11,7 @@ authors:
11
11
  autorequire:
12
12
  bindir: bin
13
13
  cert_chain: []
14
- date: 2014-02-25 00:00:00.000000000 Z
14
+ date: 2014-03-25 00:00:00.000000000 Z
15
15
  dependencies:
16
16
  - !ruby/object:Gem::Dependency
17
17
  name: rest-client