shrine-transloadit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9ad060395c4432e137702840eba7f23eef980b5
+  data.tar.gz: 983a7aaf98794573d4f946fe14d0014162b02bfd
+SHA512:
+  metadata.gz: 48003055afa7b725f0f42213daf2dedb6ecf91d03f8c5805921b0ff57953202aa0a8463300a40246cb1b0984eda816972cd8a0af2b99676188ac62bd18e010c0
+  data.tar.gz: a4aec56c9856366f4d8fb87c00ce6d6ff8f91750033ed6c0aba48b241533358c6bc5af7b4930f7bda463ebf06ff35322de5fc948d229597b8e855808439d4bdc

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,345 @@
+# Shrine::Plugins::Transloadit
+
+Provides [Transloadit] integration for [Shrine].
+
+Transloadit offers advanced file processing for all sorts of media, including
+images, videos, audio, and documents, along with importing from and exporting
+to various file storage services.
+
+## Setup
+
+While Transloadit is able to export processed files to [many storage
+services], this plugin currently supports only Amazon S3 (just because there
+are no Shrine integrations written for other services on that list yet).
+
+```rb
+gem "shrine-transloadit"
+gem "aws-sdk"
+```
+
+```rb
+require "shrine"
+require "shrine/storage/s3"
+
+s3_options = {
+  access_key_id: "xyz",
+  secret_access_key: "abc",
+  region: "my-region",
+  bucket: "my-app",
+}
+
+Shrine.storages = {
+  cache: Shrine::Storage::S3.new(prefix: "cache", **s3_options),
+  store: Shrine::Storage::S3.new(prefix: "store", **s3_options),
+}
+
+Shrine.plugin :transloadit,
+  auth_key:    "your transloadit key",
+  auth_secret: "your transloadit secret"
+```
+```rb
+post "/webhooks/transloadit" do
+  Shrine::Attacher.transloadit_save(params)
+end
+```
+
+## How it works
+
+Transloadit works in a way that you create an "assembly", which contains all
+information about how the file(s) should be processed, from import to export.
+Processing itself happens asynchronously, and you can give Transloadit a URL
+which it will POST results to when processing finishes.
+
+This plugin allows you to easily implement this webhook flow. You can intercept
+promoting, and submit a Transloadit assembly using the cached file, along with
+a URL to the route in your app where you'd like Transloadit to POST the results
+of processing. Then you can call the plugin again in the route to save the
+results to your attachment column.
+
+## Usage
+
+Transloadit assemblies are built inside `#transloadit_process` method in your
+uploader, and you can use some convenient helper methods which the plugin
+provides.
+
+```rb
+class MyUploader < Shrine
+  def transloadit_process(io, context)
+    resized = transloadit_file(io)
+      .add_step("resize", "/image/resize", width: 800)
+
+    transloadit_assembly(resized, context: context)
+  end
+end
+```
+
+These helper methods just provide a higher-level interface over the
+[transloadit gem], which you might want look at to get a better understanding
+of how building assemblies works.
+
+In short, in Transloadit every action, be it import, processing, or export, is
+a "step". Each step is defined by its [robot and arguments], and needs to have
+a *unique name*. Transloadit allows you to define the entire processing flow
+(which can result in multiple files) as a collection of steps, which is called
+an "assembly". Once the assembly is built it can be submitted to Transloadit.
+
+### Versions
+
+With Transloadit you can create multiple files in a single assembly, and this
+plugin allows you to leverage that in form of a hash of versions.
+
+```rb
+class MyUploader < Shrine
+  plugin :versions
+
+  def transloadit_process(io, context)
+    original = transloadit_file(io)
+    medium = original.add_step("resize_500", "/image/resize", width: 500)
+    small = original.add_step("resize_300", "/image/resize", width: 300)
+
+    files = {original: original, medium: medium, small: small}
+
+    transloadit_assembly(files, context: context)
+  end
+end
+```
+
+### Webhooks
+
+Transloadit performs its processing asynchronously, and you can provide a URL
+where you want Transloadit to POST results of processing once it's finished.
+
+```rb
+class MyUploader < Shrine
+  def transloadit_process(io, context)
+    # ...
+
+    transloadit_assembly(files, notify_url: "http://myapp.com/webhooks/transloadit")
+  end
+end
+```
+
+Then in your `POST /webhooks/transloadit` route you can call the plugin to
+automatically save the results to the attachment column in Shrine's format.
+
+```rb
+post "/webhooks/transloadit" do
+  Shrine::Attacher.transloadit_save(params)
+end
+```
+
+### Templates
+
+Transloadit recommends using [templates], since they allow you to replay failed
+assemblies, and also allow you not to expose credentials in your HTML.
+
+Here is an example where the whole processing is defined inside a template,
+and we just set the location of the imported file.
+
+```rb
+# Your saved template
+{
+  steps: {
+    import: {
+      robot: "/http/import",
+      url: "..."
+    },
+    resize: {
+      robot: "/image/resize",
+      use: "import",
+      width: 800
+    }
+  }
+}
+```
+```rb
+class MyUploader < Shrine
+  def transloadit_process(io, context)
+    transloadit_assembly("my_template", steps: {import: {url: io.url}})
+  end
+end
+```
+
+### Backgrounding
+
+Even though submitting a Transloadit assembly doesn't require any uploading, it
+still does two HTTP requests, so you might want to put it into a backgrond job.
+This plugin naturally hooks onto Shrine's backgrounding plugin:
+
+```rb
+Shrine::Attacher.promote { |data| TransloaditJob.perform_async(data) }
+```
+```rb
+class TransloaditJob
+  include Sidekiq::Worker
+
+  def perform(data)
+    Shrine::Attacher.transloadit_process(data)
+  end
+end
+```
+
+### Tracking progress
+
+When an assembly is submitted, Transloadit returns a lot of useful information
+about the status of that assembly, which the plugin saves to the cached
+attachment's metadata.
+
+```rb
+response = photo.image.transloadit_response
+response.body #=>
+# {
+#   "ok"                 => "ASSEMBLY_EXECUTING",
+#   "message"            => "The assembly is currently being executed.",
+#   "assembly_id"        => "83d07d10414011e68cc8c5df79919836",
+#   "assembly_url"       => "http://api2.janani.transloadit.com/assemblies/83d07d10414011e68cc8c5df79919836",
+#   "execution_start"    => "2016/07/03 17:06:42 GMT",
+#   "execution_duration" => 2.113,
+#   "params"             => "{\"steps\":{...}}",
+#   ...
+# }
+```
+
+At an point during the execution of the assembly you can refresh this
+information:
+
+```rb
+response.finished? #=> false
+response.reload!
+response.finished? #=> true
+```
+
+### Import & Export
+
+Every `TransloaditFile` needs to have an import and an export step. This plugin
+automatically generates those steps for you:
+
+```rb
+transloadit_file(io)
+
+# is equivalent to
+
+file = transloadit_file
+file.add_step(transloadit_import_step("import", io))
+```
+
+```rb
+transloadit_assembly({original: original, thumb: thumb})
+
+# is equivalent to
+
+transloadit_assembly({
+  original: original.add_step(transloadit_export_step("export_original")),
+  thumb: thumb.add_step(transloadit_export_step("export_thumb")),
+})
+```
+
+If you want/need to generate these steps yourself, you can just use the
+expanded forms.
+
+### Transloadit gem
+
+If you want to have complete control over how steps are generated, you can just
+use the [transloadit gem] directly. This plugin doesn't care how you generate
+your steps, it only requires you to return an instance of
+`Transloadit::Assembly`.
+
+```rb
+class MyUploader < Shrine
+  def transloadit_process(io, context)
+    # build options
+    transloadit #=> #<Transloadit>
+    transloadit.assembly(options)
+  end
+end
+```
+
+The import/export helper methods simply generate a `Transloadit::Step` object,
+and you can pass additional options:
+
+```rb
+class MyUploader < Shrinee
+  def transloadit_process(io, context)
+    transloadit_import_step("import", io)             #=> #<Transloadit::Step>
+    transloadit_export_step("export", path: "mypath") #=> #<Transloadit::Step>
+  end
+end
+```
+
+The `#add_step` method for `TransloaditFile` is just a convenient way to add
+steps where `:use` is automatically set to previous step.
+
+### Testing
+
+In development or test environment you cannot use webhooks, because Transloadit
+as an external service cannot access your localhost. In this case you can just
+do polling:
+
+```rb
+class MyUploader < Shrine
+  def transloadit_process(io, context)
+    # ...
+
+    if ENV["RACK_ENV"] == "production"
+      notify_url = "https://myapp.com/webhooks/transloadit"
+    else
+      # In development we cannot receive webhooks, because Transloadit as an
+      # external service cannot reach our localhost.
+    end
+
+    transloadit_assembly(files, context: context, notify_url: notify_url)
+  end
+end
+```
+
+```rb
+class TransloaditJob
+  include Sidekiq::Worker
+
+  def perform(data)
+    attacher = Shrine::Attacher.transloadit_process(data)
+
+    # Webhooks won't work in development, so we can just use polling.
+    unless ENV["RACK_ENV"] == "production"
+      response = attacher.get.transloadit_response
+      until response.finished?
+        sleep 1
+        response.reload!
+      end
+      attacher.transloadit_save(response.body)
+    end
+  end
+end
+```
+
+## Contributing
+
+Before you can run tests, you need to first create an `.env` file in the
+project root containing your Transloadit and Amazon S3 credentials:
+
+```sh
+# .env
+TRANSLOADIT_AUTH_KEY="..."
+TRANSLOADIT_AUTH_SECRET="..."
+S3_BUCKET="..."
+S3_REGION="..."
+S3_ACCESS_KEY_ID="..."
+S3_SECRET_ACCESS_KEY="..."
+```
+
+Afterwards you can run the tests:
+
+```sh
+$ bundle exec rake test
+```
+
+## License
+
+[MIT](LICENSE.txt)
+
+[Shrine]: https://github.com/janko-m/shrine
+[Transloadit]: https://transloadit.com/
+[many storage services]: https://transloadit.com/docs/conversion-robots/#file-export-robots
+[transloadit gem]: https://github.com/transloadit/ruby-sdk
+[robot and arguments]: https://transloadit.com/docs/conversion-robots/
+[templates]: https://transloadit.com/docs/#templates

data/lib/shrine/plugins/transloadit.rb

@@ -0,0 +1,267 @@
+require "transloadit"
+require "uri"
+require "json"
+require "openssl"
+
+class Shrine
+  module Plugins
+    module Transloadit
+      def self.configure(uploader, opts = {})
+        uploader.opts[:transloadit_auth_key] = opts.fetch(:auth_key, uploader.opts[:transloadit_auth_key])
+        uploader.opts[:transloadit_auth_secret] = opts.fetch(:auth_secret, uploader.opts[:transloadit_auth_secret])
+
+        raise Error, "The :auth_key is required for transloadit plugin" if uploader.opts[:transloadit_auth_key].nil?
+        raise Error, "The :auth_secret is required for transloadit plugin" if uploader.opts[:transloadit_auth_secret].nil?
+
+        uploader.opts[:backgrounding_promote] ||= proc { transloadit_process }
+      end
+
+      def self.load_dependencies(uploader, opts = {})
+        uploader.plugin :backgrounding
+      end
+
+      module AttacherClassMethods
+        def transloadit_process(data)
+          attacher = self.load(data)
+          cached_file = attacher.uploaded_file(data["attachment"])
+          attacher.transloadit_process(cached_file)
+          attacher
+        end
+
+        def transloadit_save(params)
+          params["transloadit"] = params["transloadit"].to_json if params["transloadit"].is_a?(Hash)
+          check_transloadit_signature!(params)
+          response = JSON.parse(params["transloadit"])
+          data = response["fields"]["attacher"]
+          attacher = self.load(data)
+          cached_file = attacher.uploaded_file(data["attachment"])
+          return if cached_file != attacher.get
+          attacher.transloadit_save(response)
+          attacher
+        end
+
+        def check_transloadit_signature!(params)
+          sent_signature = params["signature"]
+          payload = params["transloadit"]
+          algorithm = OpenSSL::Digest.new('sha1')
+          secret = shrine_class.opts[:transloadit_auth_secret]
+          calculated_signature = OpenSSL::HMAC.hexdigest(algorithm, secret, payload)
+          raise Error, "Transloadit signature that was sent doesn't match the calculated signature" if calculated_signature != sent_signature
+        end
+      end
+
+      module AttacherMethods
+        def transloadit_process(cached_file = get)
+          assembly = store.transloadit_process(cached_file, context)
+          assembly.options[:fields] ||= {}
+          assembly.options[:fields]["attacher"] = self.dump.merge("attachment" => cached_file.to_json)
+          response = assembly.submit!
+          raise Error, "#{response["error"]}: #{response["message"]}" if response["error"]
+          cached_file.metadata["transloadit_response"] = response.body.to_json
+          swap(cached_file)
+        end
+
+        def transloadit_save(response)
+          if versions = response["fields"]["versions"]
+            stored_file = versions.inject({}) do |hash, (name, key)|
+              result = response["results"].fetch(key)[0]
+              uploaded_file = store.transloadit_uploaded_file(result)
+              hash.update(name => uploaded_file)
+            end
+          else
+            result = response["results"].values.last[0]
+            stored_file = store.transloadit_uploaded_file(result)
+          end
+
+          update(stored_file)
+        end
+      end
+
+      module ClassMethods
+        def transloadit
+          ::Transloadit.new(
+            key:    opts[:transloadit_auth_key],
+            secret: opts[:transloadit_auth_secret],
+          )
+        end
+      end
+
+      module InstanceMethods
+        def transloadit_uploaded_file(result)
+          case url = result.fetch("url")
+          when /amazonaws\.com/
+            raise Error, "Cannot save a processed file which wasn't exported: #{url.inspect}" if url.include?("tmp.transloadit.com")
+            path = URI(url).path
+            id = path.match(/^\/#{storage.prefix}/).post_match
+          else
+            raise Error, "The transloadit Shrine plugin doesn't support storage identified by #{url.inspect}"
+          end
+
+          self.class::UploadedFile.new(
+            "id"       => id,
+            "storage"  => storage_key,
+            "metadata" => {
+              "filename"    => result.fetch("name"),
+              "size"        => result.fetch("size"),
+              "mime_type"   => result.fetch("mime"),
+              "width"       => (result["meta"] && result["meta"]["width"]),
+              "height"      => (result["meta"] && result["meta"]["height"]),
+              "transloadit" => result["meta"],
+            }
+          )
+        end
+
+        def transloadit_import_step(name, io, **step_options)
+          uri = URI.parse(io.url)
+
+          if defined?(Storage::S3) && io.storage.is_a?(Storage::S3)
+            step = transloadit.step(name, "/s3/import",
+              key:           io.storage.s3.client.config.access_key_id,
+              secret:        io.storage.s3.client.config.secret_access_key,
+              bucket:        io.storage.bucket.name,
+              bucket_region: io.storage.s3.client.config.region,
+              path:          [*io.storage.prefix, io.id].join("/"),
+            )
+          elsif uri.scheme == "http" || uri.scheme == "https"
+            step = transloadit.step(name, "/http/import",
+              url: uri.to_s,
+            )
+          elsif uri.scheme == "ftp"
+            step = transloadit.step(name, "/ftp/import",
+              host:     uri.host,
+              user:     uri.user,
+              password: uri.password,
+              path:     uri.path,
+            )
+          else
+            raise Error, "Cannot construct a transloadit import step from #{io.inspect}"
+          end
+
+          step.options.update(step_options)
+
+          step
+        end
+
+        def transloadit_export_step(name, **step_options)
+          if defined?(Storage::S3) && storage.is_a?(Storage::S3)
+            step = transloadit.step(name, "/s3/store",
+              key:           storage.s3.client.config.access_key_id,
+              secret:        storage.s3.client.config.secret_access_key,
+              bucket:        storage.bucket.name,
+              bucket_region: storage.s3.client.config.region
+            )
+          else
+            raise Error, "Cannot construct a transloadit export step from #{storage.inspect}"
+          end
+
+          step.options.update(step_options)
+
+          step
+        end
+
+        def transloadit_file(io = nil)
+          file = TransloaditFile.new(transloadit: transloadit)
+          file = file.add_step(transloadit_import_step("import", io)) if io
+          file
+        end
+
+        def transloadit_assembly(value, context: {}, **options)
+          options[:steps] ||= []
+          options[:fields] ||= {}
+
+          if (versions = value).is_a?(Hash)
+            options[:fields]["versions"] = {}
+            raise Error, "The versions Shrine plugin isn't loaded" if !defined?(Shrine::Plugins::Versions)
+            versions.each do |name, transloadit_file|
+              raise Error, "The given TransloaditFile is missing an import step" if !transloadit_file.imported?
+              unless transloadit_file.exported?
+                path = generate_location(transloadit_file, context.merge(version: name)) + ".${file.ext}"
+                export_step = transloadit_export_step("export_#{name}", path: path)
+                transloadit_file = transloadit_file.add_step(export_step)
+              end
+              options[:steps] |= transloadit_file.steps
+              options[:fields]["versions"][name] = transloadit_file.name
+            end
+          elsif (transloadit_file = value).is_a?(TransloaditFile)
+            raise Error, "The given TransloaditFile is missing an import step" if !transloadit_file.imported?
+            unless transloadit_file.exported?
+              path = generate_location(transloadit_file, context) + ".${file.ext}"
+              export_step = transloadit_export_step("export", path: path)
+              transloadit_file = transloadit_file.add_step(export_step)
+            end
+            options[:steps] += transloadit_file.steps
+          elsif (template = value).is_a?(String)
+            options[:template_id] = template
+          else
+            raise Error, "First argument has to be a TransloaditFile, a hash of TransloaditFiles, or a template"
+          end
+
+          if options[:steps].uniq(&:name) != options[:steps]
+            raise Error, "There are different transloadit steps using the same name"
+          end
+
+          transloadit.assembly(options)
+        end
+
+        def transloadit
+          @transloadit ||= self.class.transloadit
+        end
+      end
+
+      module FileMethods
+        def transloadit_response
+          @transloadit_response ||= (
+            body = metadata.fetch("transloadit_response")
+            body.instance_eval { def body; self; end }
+            response = ::Transloadit::Response.new(body)
+            response.extend ::Transloadit::Response::Assembly
+            response
+          )
+        end
+      end
+
+      class TransloaditFile
+        attr_reader :transloadit, :steps
+
+        def initialize(transloadit:, steps: [])
+          @transloadit = transloadit
+          @steps = steps
+        end
+
+        def add_step(*args)
+          if args[0].is_a?(::Transloadit::Step)
+            step = args[0]
+          else
+            step = transloadit.step(*args)
+          end
+
+          unless step.options[:use]
+            step.use @steps.last if @steps.any?
+          end
+
+          TransloaditFile.new(transloadit: transloadit, steps: @steps + [step])
+        end
+
+        # Transloadit in its result uses the name of the last step before the
+        # export step.
+        def name
+          if exported?
+            @steps[-2].name
+          else
+            @steps.last.name
+          end
+        end
+
+        def imported?
+          @steps.any? && @steps.first.robot.end_with?("/import")
+        end
+
+        def exported?
+          @steps.any? && @steps.last.robot.end_with?("/store")
+        end
+      end
+    end
+
+    register_plugin(:transloadit, Transloadit)
+  end
+end

data/shrine-transloadit.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |gem|
+  gem.name          = "shrine-transloadit"
+  gem.version       = "0.1.0"
+
+  gem.required_ruby_version = ">= 2.1"
+
+  gem.summary      = "Provides Transloadit integration for Shrine."
+  gem.homepage     = "https://github.com/janko-m/shrine-transloadit"
+  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.1"
+  gem.add_dependency "transloadit", "~> 1.2"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-hooks"
+  gem.add_development_dependency "dotenv"
+  gem.add_development_dependency "aws-sdk"
+  gem.add_development_dependency "sequel"
+  gem.add_development_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: shrine-transloadit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shrine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: transloadit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !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: minitest-hooks
+  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'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  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: sequel
+  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: sqlite3
+  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/plugins/transloadit.rb
+- shrine-transloadit.gemspec
+homepage: https://github.com/janko-m/shrine-transloadit
+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 Transloadit integration for Shrine.
+test_files: []
+has_rdoc: