shrine-cloudinary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b19b7d283d488e20abf633289dedc3d75ac9a7af
+  data.tar.gz: 46697c64a6bd24e8817980dc7e6fe751f116a98a
+SHA512:
+  metadata.gz: e0daa86740883310ba8da21250e453e5e749e10ee2eb355dcfe13e44f67a132295a6161308e0c50e1d93f439b0ab9f0b7ecab3515da017f8d1cc88eeb641ecfe
+  data.tar.gz: 947ead1c71d809c52bd4ee4fac40823acefd7176ee993f83f5bc45c50a904ef72027506a5fdbe7b04f19ac683b7eecb41479e00f1d6569c9f2a6b27c25c3c522

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Janko Marohnić
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,163 @@
+# Shrine::Cloudinary
+
+Provides [Cloudinary] storage for [Shrine].
+
+## Installation
+
+```ruby
+gem "shrine-cloudinary"
+```
+
+## Usage
+
+First you need to configure the Cloudinary gem:
+
+```rb
+require "cloudinary"
+
+Cloudinary.config(
+  cloud_name: "...",
+  api_key:    "...",
+  api_secret: "...",
+)
+
+
+You can now initialize your storage:
+
+```rb
+require "shrine/storage/cloudinary"
+
+Shrine.storages[:store] = Shrine::Storage::Cloudinary.new
+```
+
+### Copying
+
+If you're using storage as cache where files are accessible over internet,
+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
+
+The storage defaults the resource type to "image", but you can change that
+by passing the `:resource_type` option:
+
+```rb
+Shrine::Storage::Cloudinary.new(resource_type: "video") # "image", "video" or "raw"
+```
+
+### Subdirectory
+
+You can choose to store your files in a subdirectory with the `:prefix` option:
+
+```rb
+Shrine::Storage::Cloudinary.new(prefix: "uploads")
+```
+
+### Upload options
+
+If you want some [Cloudinary options] to be applied to all uploads, you can
+specify `:upload_options`:
+
+```rb
+Shrine::Storage::Cloudinary.new(upload_options: {type: "authenticated"})
+```
+
+### Transformations
+
+Cloudinary allows you to do incoming and eager file transformations, which means
+it's possible to trigger file processing on upload. In Shrine you can leverage
+that by adding `"cloudinary"` metadata, which you can do by overriding
+`Shrine#extract_metadata`:
+
+```rb
+class MyUploader < Shrine
+  def extract_metadata(io, context)
+    metadata = super
+    metadata["cloudinary"] = {
+      format: "png",
+      eager: [
+        {transformation: "small"},
+        {transformation: "medium"},
+        {transformation: "large"},
+      ]
+    }
+    metadata
+  end
+end
+```
+
+The above example will trigger named transformations "small", "medium" and
+"large", which can be configured in the Cloudinary management console. This
+means that you can have different thumbnails of an image, and it's all taken
+care of by Cloudinary. When displaying the URL the view, you just need to pass
+in the version name to the uploaded file:
+
+```rb
+user.avatar_url(transformation: "small")
+user.avatar_url(transformation: "medium")
+user.avatar_url(transformation: "large")
+```
+
+### Large files
+
+If you're uploading large files with Cloudinary (like videos), you can take
+advantage of Cloudinary's special "chunked" upload API, by passing the filesize
+threshold after which the special API will be used:
+
+```rb
+# Upload files larger than 100 MB using the "chunked" upload API
+Shrine::Storage::Cloudinary.new(large: 100*1024*1024)
+```
+
+The default chunk size is 20 MB, but you can change that by passing
+`:chunk_size` to `:upload_options`:
+
+```rb
+Shrine::Storage::Cloudinary.new(
+  large: 100*1024*1024                      # 100 MB
+  upload_options: {chunk_size: 5*1024*1204} # 5 MB
+)
+```
+
+### Metadata
+
+If you decide to do incoming transformations (processing which is done on the
+main file before it is saved to Cloudinary), shrine-cloudinary will automatically
+update format, size, width and height metadata for the uploaded file.
+
+### Clearing storage
+
+You can delete all files from the Cloudinary storage in the same way as you do
+with other storages:
+
+```rb
+cloudinary = Shrine::Storage::Cloudinary.new
+# ...
+cloudinary.clear!(:confirm)
+```
+
+## Contributing
+
+Firstly you need to create an `.env` file with Cloudinary credentials:
+
+```sh
+# .env
+CLOUDINARY_CLOUD_NAME="..."
+CLOUDINARY_API_KEY="..."
+CLOUDINARY_API_SECRET="..."
+```
+
+Afterwards you can run the tests:
+
+```sh
+$ bundle exec rake test
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)
+
+[Cloudinary]: http://cloudinary.com/
+[Shrine]: https://github.com/janko-m/shrine
+[Cloudinary options]: http://cloudinary.com/documentation/upload_images#remote_upload

data/lib/shrine/storage/cloudinary.rb

@@ -0,0 +1,128 @@
+require "cloudinary"
+require "down"
+
+class Shrine
+  module Storage
+    class Cloudinary
+      attr_reader :prefix, :resource_type, :upload_options
+
+      def initialize(prefix: nil, large: nil, resource_type: "image", upload_options: {})
+        @prefix = prefix
+        @large = large
+        @resource_type = resource_type
+        @upload_options = upload_options.merge(resource_type: resource_type)
+      end
+
+      def upload(io, id, metadata = {})
+        options = {public_id: public_id(id)}
+        options.update(upload_options)
+        options.update(metadata.delete("cloudinary") || {})
+
+        chunk_size = options.delete(:chunk_size)
+
+        result =
+          if remote?(io)
+            uploader.upload(io.storage.url(io.id), **options)
+          elsif large?(io)
+            uploader.upload_large(io, chunk_size: chunk_size, **options)
+          else
+            uploader.upload(io, **options)
+          end
+
+        update_id!(result, id)
+        update_metadata!(result, metadata)
+      end
+
+      def download(id)
+        Down.download(url(id))
+      end
+
+      def move(io, id, metadata = {})
+        uploader.rename(io.storage.public_id(io.id), public_id(id), resource_type: resource_type)
+      end
+
+      def movable?(io, id)
+        io.is_a?(UploadedFile) && io.storage.is_a?(Storage::Cloudinary)
+      end
+
+      def open(id)
+        download(id)
+      end
+
+      def read(id)
+        downloader.download(url(id))
+      end
+
+      def exists?(id)
+        result = api.resources_by_ids([public_id(id)], resource_type: resource_type)
+        result.fetch("resources").any?
+      end
+
+      def delete(id)
+        uploader.destroy(public_id(id), resource_type: resource_type)
+      end
+
+      def multi_delete(ids)
+        public_ids = ids.map { |id| public_id(id) }
+        api.delete_resources(public_ids, resource_type: resource_type)
+      end
+
+      def url(id, **options)
+        utils.cloudinary_url(path(id), resource_type: resource_type, type: type, **options)
+      end
+
+      def clear!(confirm = nil, **options)
+        raise Shrine::Confirm unless confirm == :confirm
+        if prefix
+          api.delete_resources_by_prefix(prefix, resource_type: resource_type, **options)
+        else
+          api.delete_all_resources(resource_type: resource_type, **options)
+        end
+      end
+
+      protected
+
+      def public_id(id)
+        if resource_type == "raw"
+          path(id)
+        else
+          path(id).chomp(File.extname(id))
+        end
+      end
+
+      def path(id)
+        [*prefix, id].join("/")
+      end
+
+      private
+
+      def type
+        upload_options[:type] || "upload"
+      end
+
+      def remote?(io)
+        io.is_a?(UploadedFile) && io.storage.url(io.id) =~ /^ftp:|^https?:/
+      end
+
+      def large?(io)
+        io.size >= @large if @large
+      end
+
+      def update_id!(result, id)
+        unless resource_type == "raw" || id.frozen?
+          id.gsub!(/#{File.extname(id)}$/, ".#{result.fetch("format")}")
+        end
+      end
+
+      def update_metadata!(result, metadata)
+        size, width, height = result.values_at("bytes", "width", "height")
+        metadata.update("size" => size)
+        metadata.update("width" => width, "height" => height) if resource_type == "image"
+      end
+
+      [:Uploader, :Downloader, :Utils, :Api].each do |name|
+        define_method(name.downcase) { ::Cloudinary.const_get(name) }
+      end
+    end
+  end
+end

data/shrine-cloudinary.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |gem|
+  gem.name          = "shrine-cloudinary"
+  gem.version       = "0.1.0"
+
+  gem.required_ruby_version = ">= 2.1"
+
+  gem.summary      = "Provides Cloudinary storage for Shrine."
+  gem.homepage     = "https://github.com/janko-m/shrine-cloudinary"
+  gem.authors      = ["Janko Marohnić"]
+  gem.email        = ["janko.marohnic@gmail.com"]
+  gem.license      = "MIT"
+
+  gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "shrine-cloudinary.gemspec"]
+  gem.require_path = "lib"
+
+  gem.add_dependency "cloudinary"
+  gem.add_dependency "down", ">= 1.0.3"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "shrine"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "dotenv"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: shrine-cloudinary
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cloudinary
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: down
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shrine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- janko.marohnic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/shrine/storage/cloudinary.rb
+- shrine-cloudinary.gemspec
+homepage: https://github.com/janko-m/shrine-cloudinary
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Provides Cloudinary storage for Shrine.
+test_files: []
+has_rdoc: