shrine-uploadcare 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ea3771f54e872cfdf9a254fc21c824fe0926d6e
+  data.tar.gz: 87e4f1c355642caca1d86e0411eb09c9b2c496c9
+SHA512:
+  metadata.gz: e013043a5c1717069c41aa4f17cb84c2de9eca70dd0b1c1f6a261748d975a6ebd4cc886d3b61fafcfda81cd8755bfa69b9f56f8f076139d581e1e2da6a8ddde3
+  data.tar.gz: a0e69937e1c7b275fd537ae56dddb8180275b76ecf74991ac36a622242b5065959c5ef2afd7d12be7b3d5e351ccf15da52adc5fff563f62e898f4082fd69bd2f

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 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,133 @@
+# Shrine::Storage::Uploadcare
+
+Provides [Uploadcare] storage for [Shrine].
+
+Uploadcare offers file storage with a CDN and on-demand image processing, along
+with an advanced HTML widget for direct uploads.
+
+## Installation
+
+```ruby
+gem "shrine-uploadcare"
+```
+
+## Usage
+
+```rb
+require "shrine"
+require "shrine/storage/uploadcare"
+
+uploadcare_options = {
+  public_key:  "...",
+  private_key: "...",
+}
+
+Shrine.storages = {
+  cache: Shrine::Storage::Uploadcare.new(**uploadcare_options),
+  store: Shrine::Storage::Uploadcare.new(**uploadcare_options),
+}
+```
+
+### Direct uploads
+
+Uploadcare supports uploading files directly to the service, freeing your
+application from accepting file uploads. The easiest way to do that is by using
+Uploadcare's [HTML widget], you can see how it can be used in the
+shrine-uploadcare [demo app].
+
+[Secure file uploads] are also supported, you can generate signatures with
+`#presign` on the storage, or using the [direct_upload plugin] with `presign:
+true`.
+
+### URL operations
+
+You can generate Uploadcare's [URL operations] by passing options to `#url`:
+
+```rb
+photo.image_url(resize: "200x")
+photo.image_url(crop: ["200x300", :center])
+```
+
+### Upload options
+
+You can add upload options using the upload_options plugin or using
+`:upload_options` on the storage:
+
+```rb
+Shrine::Storage::Cloudinary.new(upload_options: {...}, **uploadcare_options)
+```
+
+### Storing information
+
+You can have all Uploadcare file information saved in the uploaded file's
+metadata:
+
+```rb
+Shrine::Storage::Uploadcare.new(store_info: true, **uploadcare_options)
+```
+```rb
+user = User.create(avatar: image_file)
+user.avatar.metadata["uploadcare"] #=>
+# {
+#   "type" => "file",
+#   "result" => {
+#     "original_file_url" => "http://www.ucarecdn.com/d1d2dc43-4904-4783-bb4d-fbcf64264e63/image.png",
+#     "image_info" => {
+#       "height" => 45,
+#       "width" => 91,
+#       "geo_location" => null,
+#       "datetime_original" => null,
+#       "format" => "PNG"
+#     },
+#     "mime_type" => "image/png",
+#     "is_ready" => true,
+#     "url" => "https://api.uploadcare.com/files/d1d2dc43-4904-4783-bb4d-fbcf64264e63/",
+#     "uuid" => "d1d2dc43-4904-4783-bb4d-fbcf64264e63",
+#     "original_filename" => "image.png",
+#     "datetime_uploaded" => "2014-09-09T16:48:57.284Z",
+#     "size" => 12952,
+#     "is_image" => null,
+#     "datetime_stored" => "2014-09-09T16:48:57.291Z",
+#     "datetime_removed" => null,
+#     "source" => "/03ccf9ab-f266-43fb-973d-a6529c55c2ae/"
+#   }
+# }
+```
+
+### Clearing storage
+
+You can delete all files from the Uploadcare storage in the same way as you do
+with other storages:
+
+```rb
+uploadcare = Shrine::Storage::Uploadcare.new(**options)
+# ...
+uploadcare.clear!
+```
+
+## Contributing
+
+Firstly you need to create an `.env` file with Uploadcare credentials:
+
+```sh
+# .env
+UPLOADCARE_PUBLIC_KEY="..."
+UPLOADCARE_SECRET_KEY="..."
+```
+
+Afterwards you can run the tests:
+
+```sh
+$ rake test
+```
+## License
+
+[MIT](http://opensource.org/licenses/MIT)
+
+[Uploadcare]: https://uploadcare.com/
+[Shrine]: https://github.com/janko-m/shrine
+[HTML widget]: https://uploadcare.com/documentation/widget/
+[demo app]: /demo
+[Secure file uploads]: https://uploadcare.com/documentation/upload/#secure-uploads
+[direct_upload plugin]: http://shrinerb.com/rdoc/classes/Shrine/Plugins/DirectUpload.html
+[URL operations]: https://uploadcare.com/documentation/cdn/

data/lib/shrine/storage/uploadcare.rb

@@ -0,0 +1,181 @@
+require "shrine"
+require "uploadcare"
+require "down"
+require "net/http"
+require "uri"
+require "digest"
+
+class Shrine
+  module Storage
+    class Uploadcare
+      Error = Class.new(StandardError)
+
+      attr_reader :uploadcare
+
+      def initialize(store_info: false, upload_options: {}, **options)
+        @uploadcare = ::Uploadcare::Api.new(api_version: "0.5", **options)
+        @store_info = store_info
+        @upload_options = upload_options
+      end
+
+      def upload(io, id, shrine_metadata: {}, **upload_options)
+        result = _upload(io, id, shrine_metadata: shrine_metadata, **upload_options)
+        update_metadata!(shrine_metadata, result)
+        update_id!(id, result)
+      end
+
+      def download(id)
+        Down.download(url(id))
+      end
+
+      def open(id)
+        Down.open(url(id))
+      end
+
+      def read(id)
+        Net::HTTP.get(URI(url(id)))
+      end
+
+      def exists?(id)
+        response = api_client.get("/files/#{id}/")
+        !!response.body["datetime_stored"]
+      rescue ::Uploadcare::Error::RequestError::NotFound
+        false
+      end
+
+      def delete(id)
+        api_client.delete("/files/#{id}/storage/")
+      end
+
+      def multi_delete(ids)
+        ids, rest = ids.take(100), Array(ids[100..-1])
+        response = api_client.delete("/files/storage/") do |request|
+          request.body = ids.to_json
+          request.headers["Content-Type"] = "application/json"
+        end
+        multi_delete(rest) unless rest.empty?
+      end
+
+      def url(id, **options)
+        operations = options.to_a.map { |operation| operation.flatten.join("/") }
+        file(id, operations).cdn_url(true)
+      end
+
+      def clear!
+        response = api_client.get("/files/", stored: true, limit: 1000)
+        loop do
+          uuids = response.body["results"].map { |result| result.fetch("uuid") }
+          multi_delete(uuids) unless uuids.empty?
+          return if (next_url = response.body["next"]).nil?
+          response = api_client.get(URI(next_url).request_uri)
+        end
+      end
+
+      def presign(id = nil, **options)
+        expire = Time.now.to_i + (options[:expires_in] || 60*60)
+        secret_key = uploadcare.options[:private_key]
+
+        signature = Digest::MD5.hexdigest(secret_key + expire.to_s)
+
+        fields = {
+          UPLOADCARE_PUB_KEY: uploadcare.options[:public_key],
+          signature: signature,
+          expire: expire,
+        }
+
+        url = upload_client.url_prefix + "base/"
+
+        Struct.new(:url, :fields).new(url, fields)
+      end
+
+      protected
+
+      def file(id, operations = [])
+        ::Uploadcare::Api::File.new(uploadcare, id, operations: operations)
+      end
+
+      private
+
+      def _upload(io, id, **options)
+        if uploadcare_file?(io)
+          store(io, id, **options)
+        else
+          create(io, id, **options)
+        end
+      end
+
+      def store(io, id, **options)
+        response = api_client.put "/files/#{io.id}/storage/"
+        response.body
+      end
+
+      def create(io, id, **options)
+        if remote_file?(io)
+          create_from_url(io, id, **options)
+        else
+          create_from_file(io, id, **options)
+        end
+      end
+
+      def create_from_url(io, id, shrine_metadata: {}, **upload_options)
+        options = {source_url: io.url, store: 1, pub_key: uploadcare.options[:public_key]}
+        options.update(@upload_options).update(upload_options)
+        response = upload_client.post "/from_url/", options
+        token = response.body.fetch("token")
+
+        loop do
+          response = upload_client.get "/from_url/status/", token: token
+          raise Error, response.body["error"] if response.body["status"] == "error"
+          break response.body if response.body["status"] == "success"
+          sleep 0.5
+        end
+      rescue ::Uploadcare::Error::RequestError::Forbidden => error
+        raise Error, "You must allow \"automatic file storing\" in project settings"
+      end
+
+      def create_from_file(io, id, shrine_metadata: {}, **upload_options)
+        options = {UPLOADCARE_PUB_KEY: uploadcare.options[:public_key], UPLOADCARE_STORE: 1}
+        options.update(@upload_options).update(upload_options)
+        io = Faraday::UploadIO.new(io, shrine_metadata["mime_type"], shrine_metadata["filename"])
+        io.instance_eval { def length; size; end } # hack for multipart-post
+        response = upload_client.post "/base/", file: io, **options
+        {"uuid" => response.body.fetch("file")}
+      rescue ::Uploadcare::Error::RequestError::Forbidden => error
+        raise Error, "You must allow \"automatic file storing\" in project settings"
+      end
+
+      def api_client
+        uploadcare.instance_variable_get("@api_connection")
+      end
+
+      def upload_client
+        uploadcare.instance_variable_get("@upload_connection")
+      end
+
+      def update_metadata!(metadata, result)
+        retrieved_metadata = {
+          "mime_type" => result["mime_type"],
+          "width"     => result["image_info"] && result["image_info"]["width"],
+          "height"    => result["image_info"] && result["image_info"]["height"],
+          "size"      => result["size"],
+        }
+        retrieved_metadata.reject! { |key, value| value.nil? }
+        retrieved_metadata["uploadcare"] = result if @store_info
+
+        metadata.update(retrieved_metadata)
+      end
+
+      def update_id!(id, result)
+        id.replace(result.fetch("uuid"))
+      end
+
+      def uploadcare_file?(io)
+        io.is_a?(UploadedFile) && io.storage.is_a?(Storage::Uploadcare)
+      end
+
+      def remote_file?(io)
+        io.is_a?(UploadedFile) && io.url.to_s =~ /^ftp:|^https?:/
+      end
+    end
+  end
+end

data/shrine-uploadcare.gemspec

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

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: shrine-uploadcare
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shrine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: uploadcare-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: down
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.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: 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/uploadcare.rb
+- shrine-uploadcare.gemspec
+homepage: https://github.com/janko-m/shrine-uploadcare
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Provides Uploadcare storage for Shrine.
+test_files: []
+has_rdoc: