bucket_store 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c812fe38b957031d6fae686c11a3e615ac5a2575b563ebf96b8f0a019513d363
+  data.tar.gz: 3165a65032fc35ca76ed983a7477f0cb1a13de62d1f2b68ad6cb24e4622a0eb4
+SHA512:
+  metadata.gz: 3be0d30f1857185217c5f3b461809bf436ca2306426791af4051a2c725229d246d272ffd85aaef90792102e59c8100e66422f9c43ab9354cfb01ab4b7971e6fe
+  data.tar.gz: 9ea6b6baadf89e29b0b74d00a9ca5c743088c50d75c1867348ba48ce14ac304160f205b881747ccf4f54b3dc50f631e27f2042443e2ffbfc69913e4f1703bbb2

data/README.md

@@ -0,0 +1,167 @@
+# BucketStore
+
+An abstraction layer on the top of file cloud storage systems such as Google Cloud
+Storage or S3. This module exposes a generic interface that allows interoperability
+between different storage options. Callers don't need to worry about the specifics
+of where and how a file is stored and retrieved as long as the given key is valid.
+
+Keys within the `BucketStorage` are URI strings that can universally locate an object
+in the given provider. A valid key example would be
+`gs://a-gcs-bucket/file/path.json`.
+
+## Usage
+This library is distributed as a Ruby gem, and we recommend adding it to your Gemfile:
+
+```ruby
+gem "bucket-store"
+```
+
+Some attributes can be configured via `BucketStore.configure`. If using Rails, you want to
+add a new initializer for `BucketStore`. Example:
+
+```ruby
+BucketStore.configure do |config|
+  config.logger = Logger.new($stderr)
+end
+```
+
+If using RSpec, you'll probably want to add this line to RSpec's config block (see
+the *Adapters* section for more details):
+
+```ruby
+config.before { BucketStore::InMemory.reset! }
+```
+
+For our policy on compatibility with Ruby versions, see [COMPATIBILITY.md](docs/COMPATIBILITY.md).
+
+## Design and Architecture
+The main principle behind `BucketStore` is that each resource or group of resources must
+be unequivocally identifiable by a URI. The URI is always composed of three parts:
+
+- the "adapter" used to fetch the resource (see "adapters" below)
+- the "bucket" where the resource lives
+- the path to the resource(s)
+
+As an example, all the following are valid URIs:
+
+- `gs://gcs-bucket/path/to/file.xml`
+- `inmemory://bucket/separator/file.xml`
+- `disk://hello/path/to/file.json`
+
+Even though `BucketStore`'s main goal is to be an abstraction layer on top of systems such
+as S3 or Google Cloud Storage where the "path" to a resource is in practice a unique
+identifier as a whole (i.e. the `/` is not a directory separator but rather part of the
+key's name), we assume that clients will actually want some sort of hierarchical
+separation of resources and assume that such separation is achieved by defining each
+part of the hierarchy via `/`.
+
+This means that the following are also valid URIs in `BucketStore` but they refer to
+all the resources under that specific hierarchy:
+
+- `gs://gcs-bucket/path/subpath/`
+- `inmemory://bucket/separator/`
+- `disk://hello/path`
+
+## Configuration
+`BucketStore` exposes some configurable attributes via `BucketStore.configure`. If
+necessary this should be called at startup time before any other method is invoked.
+
+- `logger`: custom logger class. By default, logs will be sent to stdout.
+
+## Adapters
+
+`BucketStore` comes with 4 built-in adapters:
+
+- `gs`: the Google Cloud Storage adapter
+- `s3`: the S3 adapter
+- `disk`: a disk-based adapter
+- `inmemory`: an in-memory store
+
+### GS adapter
+This is the adapter for Google Cloud Storage. `BucketStore` assumes that the  authorisation
+for accessing the resources has been set up outside of the gem.
+
+### S3 adapter
+This is the adapter for S3. `BucketStore` assumes that the authorisation for accessing
+the resources has been set up outside of the gem (see also
+https://docs.aws.amazon.com/sdk-for-ruby/v3/api/index.html#Configuration).
+
+### Disk adapter
+A disk-backed key-value store. This adapter will create a temporary directory where
+all the files will be written into/read from. The base directory can be explicitly
+defined by setting the `DISK_ADAPTER_BASE_DIR` environment variable, otherwise a temporary
+directory will be created.
+
+### In-memory adapter
+An in-memory key-value storage. This works just like the disk adapter, except that
+the content of all the files is stored in memory, which is particularly useful for
+testing. Note that content added to this adapter will persist for the lifetime of
+the application as it's not possible to create different instances of the same adapter.
+In general, this is not what's expected during testing where the content of the bucket
+should be reset between different tests. The adapter provides a way to easily reset the
+content though via a `.reset!` method. In RSpec this would translate to adding this line
+in the `spec_helper`:
+
+```ruby
+config.before { BucketStore::InMemory.reset! }
+```
+
+## BucketStore vs ActiveStorage
+
+ActiveStorage is a common framework to access cloud storage systems that is included in
+the ActiveSupport library. In general, ActiveStorage provides a lot more than BucketStore
+does (including many more adapters) however the two libraries have different use cases
+in mind:
+
+- ActiveStorage requires you to define every possible bucket you're planning to use
+  ahead of time in a YAML file. This works well for most cases, however if you plan to
+  use a lot of buckets this soon becomes impractical. We think that BucketStore approach
+  works much better in this case.
+- BucketStore does not provide ways to manipulate the content whereas ActiveStorage does.
+  If you plan to apply transformations to the content before uploading or after
+  downloading them, then probably ActiveStorage is the library for you. With that said,
+  it's still possible to do these transformations outside of BucketStore and in fact we've
+  found the explicitness of this approach a desirable property.
+- BucketStore approach makes any resource on a cloud storage system uniquely identifiable
+  via a single URI, which means normally it's enough to pass that string around different
+  systems to be able to access the resource without ambiguity. As the URI also includes
+  the adapter, it's possible for example to download a `disk://dir/input_file` and
+  upload it to a `gs://bucket/output_file` all going through a single interface.
+  ActiveStorage is instead focused on persisting an equivalent reference on a Rails model.
+  If your application does not use Rails, or does not need to persist the reference or
+  just requires more flexibility in general, then BucketStore is probably the library for
+  you.
+
+
+## Examples
+
+### Uploading a file to a bucket
+```ruby
+BucketStore.for("inmemory://bucket/path/file.xml").upload!("hello world")
+=> "inmemory://bucket/path/file.xml"
+```
+
+### Accessing a file in a bucket
+```ruby
+BucketStore.for("inmemory://bucket/path/file.xml").download
+=> {:bucket=>"bucket", :key=>"path/file.xml", :content=>"hello world"}
+```
+
+### Listing all keys under a prefix
+```ruby
+BucketStore.for("inmemory://bucket/path/").list
+=> ["inmemory://bucket/path/file.xml"]
+```
+
+### Delete a file
+```ruby
+BucketStore.for("inmemory://bucket/path/file.xml").delete!
+=> true
+```
+
+## License & Contributing
+
+* BucketStore is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+* Bug reports and pull requests are welcome on GitHub at https://github.com/gocardless/file-storage.
+
+GoCardless ♥ open source. If you do too, come [join us](https://gocardless.com/about/careers/).

data/lib/bucket_store/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BucketStore
+  class Configuration
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+
+    # Specifies a custom logger.
+    #
+    # Note that {BucketStore} uses structured logging, any custom logger passed must also
+    # support it.
+    #
+    # @example Use stderr as main output device
+    #   config.logger = Logger.new($stderr)
+    # @!attribute logger
+    attr_writer :logger
+  end
+end

data/lib/bucket_store/disk.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BucketStore
+  class Disk
+    def self.build(base_dir = ENV["DISK_ADAPTER_BASE_DIR"])
+      base_dir ||= Dir.tmpdir
+      Disk.new(base_dir)
+    end
+
+    def initialize(base_dir)
+      @base_dir = File.expand_path(base_dir)
+    end
+
+    def upload!(bucket:, key:, content:)
+      File.open(key_path(bucket, key), "w") do |file|
+        file.write(content)
+      end
+      {
+        bucket: bucket,
+        key: key,
+      }
+    end
+
+    def download(bucket:, key:)
+      File.open(key_path(bucket, key), "r") do |file|
+        {
+          bucket: bucket,
+          key: key,
+          content: file.read,
+        }
+      end
+    end
+
+    def list(bucket:, key:, page_size:)
+      root = Pathname.new(bucket_root(bucket))
+
+      Dir["#{root}/**/*"].
+        reject { |absolute_path| File.directory?(absolute_path) }.
+        map { |full_path| Pathname.new(full_path).relative_path_from(root).to_s }.
+        select { |f| f.start_with?(key) }.
+        each_slice(page_size).
+        map do |keys|
+        {
+          bucket: bucket,
+          keys: keys,
+        }
+      end.to_enum
+    end
+
+    def delete!(bucket:, key:)
+      File.unlink(key_path(bucket, key))
+
+      true
+    end
+
+    private
+
+    attr_reader :base_dir
+
+    def bucket_root(bucket)
+      path = File.join(base_dir, sanitize_filename(bucket))
+      FileUtils.mkdir_p(path)
+      path
+    end
+
+    def key_path(bucket, key)
+      path = File.join(bucket_root(bucket), sanitize_filename(key))
+      path = File.expand_path(path)
+
+      unless path.start_with?(base_dir)
+        raise ArgumentError, "Directory traversal out of bucket boundaries: #{key}"
+      end
+
+      FileUtils.mkdir_p(File.dirname(path))
+      path
+    end
+
+    def sanitize_filename(filename)
+      filename.gsub(%r{[^0-9A-z.\-/]}, "_")
+    end
+  end
+end

data/lib/bucket_store/gcs.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "uri"
+
+require "google/cloud/storage"
+
+module BucketStore
+  class Gcs
+    DEFAULT_TIMEOUT_SECONDS = 30
+
+    def self.build(timeout_seconds = DEFAULT_TIMEOUT_SECONDS)
+      Gcs.new(timeout_seconds)
+    end
+
+    def initialize(timeout_seconds)
+      @storage = Google::Cloud::Storage.new(
+        timeout: timeout_seconds,
+      )
+    end
+
+    def upload!(bucket:, key:, content:)
+      buffer = StringIO.new(content)
+      get_bucket(bucket).create_file(buffer, key)
+
+      {
+        bucket: bucket,
+        key: key,
+      }
+    end
+
+    def download(bucket:, key:)
+      file = get_bucket(bucket).file(key)
+
+      buffer = StringIO.new
+      file.download(buffer)
+
+      {
+        bucket: bucket,
+        key: key,
+        content: buffer.string,
+      }
+    end
+
+    def list(bucket:, key:, page_size:)
+      Enumerator.new do |yielder|
+        token = nil
+
+        loop do
+          page = get_bucket(bucket).files(prefix: key, max: page_size, token: token)
+          yielder.yield({
+            bucket: bucket,
+            keys: page.map(&:name),
+          })
+
+          break if page.token.nil?
+
+          token = page.token
+        end
+      end
+    end
+
+    def delete!(bucket:, key:)
+      get_bucket(bucket).file(key).delete
+
+      true
+    end
+
+    private
+
+    attr_reader :storage
+
+    def get_bucket(name)
+      # Lookup only checks that the bucket actually exist before doing any work on it.
+      # Unfortunately it also requires a set of extra permissions that are not necessarily
+      # going to be granted for service accounts. Given that if the bucket doesn't exist
+      # we'll get errors down the line anyway, we can safely skip the lookup without loss
+      # of generality.
+      storage.bucket(name, skip_lookup: true)
+    end
+  end
+end

data/lib/bucket_store/in_memory.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module BucketStore
+  class InMemory
+    def self.build
+      InMemory.instance
+    end
+
+    def self.instance
+      # rubocop:disable Style/ClassVars
+      @@instance ||= new
+      # rubocop:enable Style/ClassVars
+    end
+
+    def self.reset!
+      instance.reset!
+    end
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @buckets = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def upload!(bucket:, key:, content:)
+      @buckets[bucket][key] = content
+
+      {
+        bucket: bucket,
+        key: key,
+      }
+    end
+
+    def download(bucket:, key:)
+      {
+        bucket: bucket,
+        key: key,
+        content: @buckets[bucket].fetch(key),
+      }
+    end
+
+    def list(bucket:, key:, page_size:)
+      @buckets[bucket].keys.
+        select { |k| k.start_with?(key) }.
+        each_slice(page_size).
+        map do |keys|
+          {
+            bucket: bucket,
+            keys: keys,
+          }
+        end.to_enum
+    end
+
+    def delete!(bucket:, key:)
+      @buckets[bucket].delete(key)
+
+      true
+    end
+  end
+end

data/lib/bucket_store/key_context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BucketStore
+  class KeyContext
+    attr_reader :adapter, :bucket, :key
+
+    class KeyParseException < RuntimeError; end
+
+    def initialize(adapter:, bucket:, key:)
+      @adapter = adapter
+      @bucket = bucket
+      @key = key
+    end
+
+    def to_s
+      "<KeyContext adapter:#{adapter} bucket:#{bucket} key:#{key}>"
+    end
+
+    def self.parse(raw_key)
+      uri = URI(raw_key)
+
+      # A key should never be `nil` but can be empty. Depending on the operation, this may
+      # or may not be a valid configuration (e.g. an empty key is likely valid on a
+      # `list`, but not during a `download`).
+      key = uri.path.sub!(%r{/}, "") || ""
+
+      raise KeyParseException if [uri.scheme, uri.host, key].map(&:nil?).any?
+
+      KeyContext.new(adapter: uri.scheme,
+                     bucket: uri.host,
+                     key: key)
+    end
+  end
+end

data/lib/bucket_store/key_storage.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "bucket_store/timing"
+require "bucket_store/in_memory"
+require "bucket_store/gcs"
+require "bucket_store/s3"
+require "bucket_store/disk"
+
+module BucketStore
+  class KeyStorage
+    SUPPORTED_ADAPTERS = {
+      gs: Gcs,
+      s3: S3,
+      inmemory: InMemory,
+      disk: Disk,
+    }.freeze
+
+    attr_reader :bucket, :key, :adapter_type
+
+    def initialize(adapter:, bucket:, key:)
+      @adapter_type = adapter.to_sym
+      raise "Unknown adapter: #{@adapter_type}" unless SUPPORTED_ADAPTERS.include?(@adapter_type)
+
+      @adapter = SUPPORTED_ADAPTERS.fetch(@adapter_type).build
+      @bucket = bucket
+      @key = key
+    end
+
+    def filename
+      File.basename(key)
+    end
+
+    # Downloads the content of the reference key
+    #
+    # @return [Hash<Symbol, Object>]
+    #   A hash that includes the download result. The hash keys reference different aspects of the
+    #   download (e.g. `:key` and `:content` will include respectively the original key's name and
+    #   the actual download's content)
+    #
+    # @example Download a key
+    #   BucketStore.for("inmemory://bucket/file.xml").download
+    def download
+      raise ArgumentError, "Key cannot be empty" if key.empty?
+
+      BucketStore.logger.info(event: "key_storage.download_started")
+
+      start = BucketStore::Timing.monotonic_now
+      result = adapter.download(bucket: bucket, key: key)
+
+      BucketStore.logger.info(event: "key_storage.download_finished",
+                              duration: BucketStore::Timing.monotonic_now - start)
+
+      result
+    end
+
+    # Uploads the given content to the reference key location.
+    #
+    # If the `key` already exists, its content will be replaced by the one in input.
+    #
+    # @param [String] content The content to upload
+    # @return [String] The final `key` where the content has been uploaded
+    # @example Upload a file
+    #   BucketStore.for("inmemory://bucket/file.xml").upload("hello world")
+    def upload!(content)
+      raise ArgumentError, "Key cannot be empty" if key.empty?
+
+      BucketStore.logger.info(event: "key_storage.upload_started",
+                              **log_context)
+
+      start = BucketStore::Timing.monotonic_now
+      result = adapter.upload!(
+        bucket: bucket,
+        key: key,
+        content: content,
+      )
+
+      BucketStore.logger.info(event: "key_storage.upload_finished",
+                              duration: BucketStore::Timing.monotonic_now - start,
+                              **log_context)
+
+      "#{adapter_type}://#{result[:bucket]}/#{result[:key]}"
+    end
+
+    # Lists all keys for the current adapter that have the reference key as prefix
+    #
+    # Internally, this method will paginate through the result set. The default page size
+    # for the underlying adapter can be controlled via the `page_size` argument.
+    #
+    # This will return a enumerator of valid keys in the format of `adapter://bucket/key`.
+    # The keys in the list will share the reference key as a prefix. Underlying adapters will
+    # paginate the result set as the enumerable is consumed. The number of items per page
+    # can be controlled by the `page_size` argument.
+    #
+    # @param [Integer] page_size
+    #   the max number of items to fetch for each page of results
+    def list(page_size: 1000)
+      BucketStore.logger.info(event: "key_storage.list_started")
+
+      start = BucketStore::Timing.monotonic_now
+      pages = adapter.list(
+        bucket: bucket,
+        key: key,
+        page_size: page_size,
+      )
+
+      page_count = 0
+      Enumerator.new do |yielder|
+        pages.each do |page|
+          page_count += 1
+          keys = page.fetch(:keys, []).map { |key| "#{adapter_type}://#{page[:bucket]}/#{key}" }
+
+          BucketStore.logger.info(
+            event: "key_storage.list_page_fetched",
+            resource_count: keys.count,
+            page: page_count,
+            duration: BucketStore::Timing.monotonic_now - start,
+          )
+
+          keys.each do |key|
+            yielder.yield(key)
+          end
+        end
+      end
+    end
+
+    # Deletes the referenced key.
+    #
+    # Note that this method will always return true.
+    #
+    # @return [bool]
+    #
+    # @example Delete a file
+    #   BucketStore.for("inmemory://bucket/file.txt").delete!
+    def delete!
+      BucketStore.logger.info(event: "key_storage.delete_started")
+
+      start = BucketStore::Timing.monotonic_now
+      adapter.delete!(bucket: bucket, key: key)
+
+      BucketStore.logger.info(event: "key_storage.delete_finished",
+                              duration: BucketStore::Timing.monotonic_now - start)
+
+      true
+    end
+
+    private
+
+    attr_reader :adapter
+
+    def log_context
+      {
+        bucket: bucket,
+        key: key,
+        adapter_type: adapter_type,
+      }.compact
+    end
+  end
+end

data/lib/bucket_store/s3.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "uri"
+
+require "aws-sdk-s3"
+
+module BucketStore
+  class S3
+    DEFAULT_TIMEOUT_SECONDS = 30
+
+    def self.build(open_timeout_seconds = DEFAULT_TIMEOUT_SECONDS,
+                   read_timeout_seconds = DEFAULT_TIMEOUT_SECONDS)
+      S3.new(open_timeout_seconds, read_timeout_seconds)
+    end
+
+    def initialize(open_timeout_seconds, read_timeout_seconds)
+      @storage = Aws::S3::Client.new(
+        http_open_timeout: open_timeout_seconds,
+        http_read_timeout: read_timeout_seconds,
+      )
+    end
+
+    def upload!(bucket:, key:, content:)
+      storage.put_object(
+        bucket: bucket,
+        key: key,
+        body: content,
+      )
+
+      {
+        bucket: bucket,
+        key: key,
+      }
+    end
+
+    def download(bucket:, key:)
+      file = storage.get_object(
+        bucket: bucket,
+        key: key,
+      )
+
+      {
+        bucket: bucket,
+        key: key,
+        content: file.body.read,
+      }
+    end
+
+    def list(bucket:, key:, page_size:)
+      Enumerator.new do |yielder|
+        page = storage.list_objects_v2(bucket: bucket, prefix: key, max_keys: page_size)
+
+        loop do
+          yielder.yield({
+            bucket: bucket,
+            keys: page.contents.map(&:key),
+          })
+
+          break unless page.next_page?
+
+          page = page.next_page
+        end
+      end
+    end
+
+    def delete!(bucket:, key:)
+      storage.delete_object(
+        bucket: bucket,
+        key: key,
+      )
+
+      true
+    end
+
+    private
+
+    attr_reader :storage
+  end
+end

data/lib/bucket_store/timing.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BucketStore
+  module Timing
+    # "Wall clock is for telling time, monotonic clock is for measuring time."
+    #
+    # When timing events, ensure we ask for a monotonically adjusted clock time
+    # to avoid changes to the system time from being reflected in our
+    # measurements.
+    #
+    # See this article for a good explanation and a deeper dive:
+    # https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/
+    #
+    # @return [Float]
+    def self.monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/bucket_store/uri_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BucketStore
+  module UriBuilder
+    # Sanitizes the input as not all characters are valid as either URIs or as bucket keys.
+    # When we get them we want to replace them with something we can process.
+    #
+    # @param input [String] the string to sanitise
+    # @param [String] replacement the replacement string for invalid characters
+    # @return [String] the sanitised string
+    def self.sanitize(input, replacement = "__")
+      input.gsub(/[{}<>%]/, replacement)
+    end
+  end
+end

data/lib/bucket_store/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BucketStore
+  VERSION = "0.3.0"
+end

data/lib/bucket_store.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "bucket_store/version"
+require "bucket_store/configuration"
+require "bucket_store/key_context"
+require "bucket_store/key_storage"
+
+# An abstraction layer on the top of file cloud storage systems such as Google Cloud
+# Storage or S3. This module exposes a generic interface that allows interoperability
+# between different storage options. Callers don't need to worry about the specifics
+# of where and how a file is stored and retrieved as long as the given key is valid.
+#
+# Keys within the {BucketStore} are URI strings that can universally locate an object
+# in the given provider. A valid key example would be:
+# `gs://gcs-bucket/file/path.json`.
+module BucketStore
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= BucketStore::Configuration.new
+    end
+
+    # Yields a {BucketStore::Configuration} object that allows callers to configure
+    # BucketStore's behaviour.
+    #
+    # @yield [BucketStore::Configuration]
+    #
+    # @example Configure BucketStore to use a different logger than the default
+    #   BucketStore.configure do |config|
+    #     config.logger = Logger.new($stderr)
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    # Given a `key` in the format of `adapter://bucket/key` returns the corresponding
+    # adapter that will allow to manipulate (e.g. download, upload or list) such key.
+    #
+    # Currently supported adapters are `gs` (Google Cloud Storage), `inmemory` (an
+    # in-memory key-value storage) and `disk` (a disk-backed key-value store).
+    #
+    # @param [String] key The reference key
+    # @return [KeyStorage] An interface to the adapter that can handle requests on the given key
+    # @example Configure {BucketStore} for Google Cloud Storage
+    #   BucketStore.for("gs://the_bucket/a/valid/key")
+    def for(key)
+      ctx = KeyContext.parse(key)
+
+      KeyStorage.new(adapter: ctx.adapter,
+                     bucket: ctx.bucket,
+                     key: ctx.key)
+    end
+  end
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: bucket_store
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- GoCardless Engineering
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: google-cloud-storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+- !ruby/object:Gem::Dependency
+  name: gc_ruboconfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.29'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.29'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: "    A helper library to access cloud storage services such as Google
+  Cloud Storage.\n"
+email:
+- engineering@gocardless.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bucket_store.rb
+- lib/bucket_store/configuration.rb
+- lib/bucket_store/disk.rb
+- lib/bucket_store/gcs.rb
+- lib/bucket_store/in_memory.rb
+- lib/bucket_store/key_context.rb
+- lib/bucket_store/key_storage.rb
+- lib/bucket_store/s3.rb
+- lib/bucket_store/timing.rb
+- lib/bucket_store/uri_builder.rb
+- lib/bucket_store/version.rb
+homepage: https://github.com/gocardless/file-storage
+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.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A helper library to access cloud storage services
+test_files: []