shrine-cloudinary 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40214d8c6cb86f477773409ad1b2bd939c9cb781
-  data.tar.gz: e17dc751f371937e136ba2f915a6df65be6ed2e9
+  metadata.gz: 88a038d6cf9285136e6a82d4ddf674f91e476802
+  data.tar.gz: a62342009fd3960a2aeed8e2dd67897bc60d568f
 SHA512:
-  metadata.gz: 9d57b2b9cb32ae0ad2f49084039ec26bc97143b657c06236f7fd452905d440b08cb983f0c2bbd12c99cb667f65abac9cd10900fc4e4a50d5998480bfdbda4b6d
-  data.tar.gz: fe772efa20d956fd9c867ba511276d8ec394d774b379aaa203802a756efce23465a6cfe7f41ea106f1b6a3fd1e7c5a3ff658698f75538c709587d9dfd6039ce1
+  metadata.gz: 8804baaf7341ecabdd1592648a3ab1181e87612e2b145c05314bfd20f384b7c4d5f062fc66ae9d00961979b4a725d58cdfda2a68ba113501f7c6eba0701c332b
+  data.tar.gz: 8bba0e77831e522c76d03616be52b04f6806c50089d8eb689bae7f8a9188cdf822973f1fd7cfed19137a4dc17f7d9bf91e4fde19e21985e462960bc3942c5dbc

data/README.md

@@ -2,6 +2,10 @@
 
 Provides [Cloudinary] storage for [Shrine].
 
+Cloudinary provides storage with advanced on-the-fly processing (as well as
+processing on upload) for both images and videos, but can also store any other
+types of files.
+
 ## Installation
 
 ```ruby
@@ -30,6 +34,13 @@ require "shrine/storage/cloudinary"
 Shrine.storages[:store] = Shrine::Storage::Cloudinary.new
 ```
 
+### Direct uploads
+
+Cloudinary supports uploading files directly to their service, thus bypassing
+your application. The easiest way to do that is to setup [direct unsigned
+uploads]. Follow the linked blog post for instructions, and see the [demo] app
+for a complete implementation.
+
 ### Copying
 
 If you're using storage as cache where files are accessible over internet,
@@ -37,7 +48,7 @@ moving the cached file to Cloudinary storage will not require another upload.
 Instead only the file URL will be passed to Cloudinary, then Cloudinary will
 internally download it and store the file.
 
-### Videos and Raw
+### Images, Videos or Raw
 
 The storage defaults the resource type to "image", but you can change that
 by passing the `:resource_type` option:
@@ -54,6 +65,14 @@ You can choose to store your files in a subdirectory with the `:prefix` option:
 Shrine::Storage::Cloudinary.new(prefix: "uploads")
 ```
 
+### Controlling access
+
+You can [control access] to uploaded files with the `:type` option:
+
+```rb
+Shrine::Storage::Cloudinary.new(type: "private") # upload, private or authenticated
+```
+
 ### Upload options
 
 If you want some [Cloudinary options] to be applied to all uploads, you can
@@ -86,8 +105,7 @@ end
 You can pass transformation options to the URLs:
 
 ```rb
-user.avatar_url(width: 100, height: 100)
-user.avatar_url(width: 0.2, crop: :scale)
+user.avatar_url(width: 100, height: 100, crop: :fit) # :crop is mandatory here
 ```
 
 See [Rails image manipulation] for all URL options you can pass in.
@@ -126,9 +144,31 @@ user.avatar.metadata["cloudinary"] #=>
 # }
 ```
 
-This is especially useful for saving [responsive breakpoints]. If you're using
-the storage directly, `Shrine::Storage::Cloudinary#upload` will return this
-hash.
+## Responsive breakpoints
+
+Cloudinary has a feature for automagically generating [responsive breakpoints]
+for images. In Shrine you can leverage this via `:upload_options` and
+`:store_data`:
+
+```rb
+Shrine::Storage::Cloudinary.new(
+  store_data: true,
+  upload_options: {responsive_breakpoints: {...}},
+  **cloudinary_options
+)
+```
+
+Now each upload will generate responsive breakpoints, and the result will be
+saved in the uploaded file's metadata hash under "cloudinary".
+
+If the `:responsive_breakpoints` value needs to be dynamic, you can use the
+upload_options plugin:
+
+```rb
+Shrine.plugin :upload_options, store: ->(io, context) do
+  {responsive_breakpoints: {...}}
+end
+```
 
 ### Large files
 
@@ -171,7 +211,7 @@ with other storages:
 ```rb
 cloudinary = Shrine::Storage::Cloudinary.new
 # ...
-cloudinary.clear!(:confirm)
+cloudinary.clear!
 ```
 
 ## Contributing
@@ -191,13 +231,21 @@ Afterwards you can run the tests:
 $ bundle exec rake test
 ```
 
+## Inspiration
+
+This gem has been inspired by [cloudinary]'s CarrierWave integration.
+
 ## License
 
 [MIT](http://opensource.org/licenses/MIT)
 
 [Cloudinary]: http://cloudinary.com/
 [Shrine]: https://github.com/janko-m/shrine
+[cloudinary]: https://github.com/cloudinary/cloudinary_gem
 [Cloudinary options]: http://cloudinary.com/documentation/upload_images#remote_upload
 [Rails image manipulation]: http://cloudinary.com/documentation/rails_image_manipulation
 [responsive breakpoints]: http://cloudinary.com/blog/introducing_intelligent_responsive_image_breakpoints_solutions
 [explicit API]: http://cloudinary.com/documentation/image_upload_api_reference#explicit
+[direct unsigned uploads]: http://cloudinary.com/blog/direct_upload_made_easy_from_browser_or_mobile_app_to_the_cloud
+[demo]: /demo
+[control access]: http://cloudinary.com/documentation/upload_images#control_access_to_images

data/lib/shrine/storage/cloudinary.rb

@@ -5,18 +5,20 @@ require "down"
 class Shrine
   module Storage
     class Cloudinary
-      attr_reader :prefix, :resource_type, :upload_options
+      attr_reader :prefix, :resource_type, :type, :upload_options
 
-      def initialize(prefix: nil, large: nil, resource_type: "image", store_data: nil, upload_options: {})
+      def initialize(prefix: nil, resource_type: "image", type: "upload", store_data: nil, upload_options: {}, large: nil)
         @prefix = prefix
         @large = large
         @resource_type = resource_type
-        @upload_options = upload_options.merge(resource_type: resource_type)
+        @type = type
+        @upload_options = upload_options
         @store_data = store_data
       end
 
       def upload(io, id, shrine_metadata: {}, **upload_options)
         options = {public_id: public_id(id)}
+        options.update(default_options)
         options.update(@upload_options)
         options.update(upload_options)
 
@@ -33,11 +35,11 @@ class Shrine
       end
 
       def update(id, **options)
-        uploader.explicit(public_id(id), resource_type: resource_type, type: type, **options)
+        ::Cloudinary::Uploader.explicit(public_id(id), default_options.merge(options))
       end
 
-      def move(io, id, metadata = {})
-        uploader.rename(io.storage.public_id(io.id), public_id(id), resource_type: resource_type)
+      def move(io, id, shrine_metadata: {}, **upload_options)
+        ::Cloudinary::Uploader.rename(io.storage.public_id(io.id), public_id(id), default_options)
       end
 
       def movable?(io, id)
@@ -49,32 +51,32 @@ class Shrine
       end
 
       def read(id)
-        downloader.download(url(id))
+        ::Cloudinary::Downloader.download(url(id), default_options)
       end
 
       def exists?(id)
-        result = api.resources_by_ids([public_id(id)], resource_type: resource_type)
+        result = ::Cloudinary::Api.resources_by_ids([public_id(id)], default_options)
         result.fetch("resources").any?
       end
 
       def delete(id)
-        uploader.destroy(public_id(id), resource_type: resource_type)
+        ::Cloudinary::Uploader.destroy(public_id(id), default_options)
       end
 
       def multi_delete(ids)
         public_ids = ids.map { |id| public_id(id) }
-        api.delete_resources(public_ids, resource_type: resource_type)
+        ::Cloudinary::Api.delete_resources(public_ids, default_options)
       end
 
       def url(id, **options)
-        utils.cloudinary_url(path(id), resource_type: resource_type, type: type, **options)
+        ::Cloudinary::Utils.cloudinary_url(path(id), default_options.merge(options))
       end
 
       def clear!(**options)
         if prefix
-          api.delete_resources_by_prefix(prefix, resource_type: resource_type, **options)
+          ::Cloudinary::Api.delete_resources_by_prefix(prefix, default_options.merge(options))
         else
-          api.delete_all_resources(resource_type: resource_type, **options)
+          ::Cloudinary::Api.delete_all_resources(default_options.merge(options))
         end
       end
 
@@ -96,21 +98,17 @@ class Shrine
 
       def store(io, chunk_size: nil, **options)
         if remote?(io)
-          uploader.upload(io.url, **options)
+          ::Cloudinary::Uploader.upload(io.url, **options)
         else
           io = io.download if io.is_a?(UploadedFile)
           if large?(io)
-            uploader.upload_large(io, chunk_size: chunk_size, **options)
+            ::Cloudinary::Uploader.upload_large(io, chunk_size: chunk_size, **options)
           else
-            uploader.upload(io, **options)
+            ::Cloudinary::Uploader.upload(io, **options)
           end
         end
       end
 
-      def type
-        upload_options[:type] || "upload"
-      end
-
       def remote?(io)
         io.is_a?(UploadedFile) && io.url.to_s =~ /^ftp:|^https?:/
       end
@@ -119,6 +117,10 @@ class Shrine
         io.size >= @large if @large
       end
 
+      def default_options
+        {resource_type: resource_type, type: type}
+      end
+
       def update_id!(result, id)
         uploaded_id  = result.fetch("public_id")
         uploaded_id  = uploaded_id.match("#{prefix}/").post_match if prefix
@@ -140,10 +142,6 @@ class Shrine
         metadata.update(retrieved_metadata)
       end
 
-      [:Uploader, :Downloader, :Utils, :Api].each do |name|
-        define_method(name.downcase) { ::Cloudinary.const_get(name) }
-      end
-
       MIME_TYPES = {
         # Images
         "jpg"  => "image/jpeg",

data/shrine-cloudinary.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name          = "shrine-cloudinary"
-  gem.version       = "0.3.0"
+  gem.version       = "0.3.1"
 
   gem.required_ruby_version = ">= 2.1"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shrine-cloudinary
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-19 00:00:00.000000000 Z
+date: 2016-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shrine