sequel-connection_guard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9deb4fcabe84e3c610ee8041ab0eaa63633f2d7525f47324e9bb2e99bc6de84e
+  data.tar.gz: d30029a4edbd19ee0427f09018fa3791e55fa4f6e9d6d38d14f3e6cee52ab4cf
+SHA512:
+  metadata.gz: 3f8fa9c222c2169cef6308dca198b6a405133990576c273ff1a4a38be299aea4a035f1fb56820a202cf0a5aed08ffaddab484ceb7f2520affc0ee07a68fcb8d8
+  data.tar.gz: 4469478b2db4f9cce22f5cb30a7db36d5edaff74871f103da1a6ec0d8bd4142afb7c6992a5afba68f27fcc6f17d9a8d131f8d9bfa46000e17a79e8ae02483669

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,24 @@
+inherit_gem:
+  rubocop-config-umbrellio: lib/rubocop.yml
+  armitage-rubocop:
+    - lib/rubocop.general.yml
+    - lib/rubocop.rspec.yml
+
+AllCops:
+  TargetRubyVersion: 2.6.3
+  Include:
+    - sequel-connection_guard.gemspec
+    - lib/**/*.rb
+    - spec/**/*.rb
+    - Gemfile
+    - Rakefile
+    - bin/console
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -0,0 +1,20 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+  - 2.6
+  - ruby-head
+
+services:
+  - postgresql
+addons:
+  postgresql: 9.6
+
+before_install: gem install bundler
+before_script:
+  - psql -c 'create database sequel_connection_guard;' -U postgres
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
+
+cache: bundler

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Alexander Komarov
+
+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,162 @@
+# sequel-connection_guard
+[![Build Status](https://travis-ci.org/umbrellio/sequel-connection_guard.svg?branch=master)](https://travis-ci.org/umbrellio/sequel-connection_guard)
+[![Coverage Status](https://coveralls.io/repos/github/umbrellio/sequel-connection_guard/badge.svg?branch=master)](https://coveralls.io/github/umbrellio/sequel-connection_guard?branch=master)
+[![Gem Version](https://badge.fury.io/rb/sequel-connection_guard.svg)](https://badge.fury.io/rb/sequel-connection_guard)
+
+This Sequel extension provides a set of abstractions for working with databases that might not be
+reachable at any given moment in time.
+
+**This gem was only tested against PostgreSQL databases.**
+
+Goals:
+- Allow to bootstrap an application when a database server is down
+- Allow to safely and explicitly access a database
+- In case connection fails, retry on next attempt
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sequel-connection_guard'
+```
+
+And then execute:
+```sh
+$ bundle
+```
+
+Enable the extension:
+```ruby
+Sequel.extension :connection_guard
+```
+
+## Usage
+
+This extension provides two main abstractions for accessing unreliable databases. These are almost
+identical, but one allows you to reach a database handle (instance of `Sequel::Database`) and
+another allows you to reach a Sequel model (instance of `Sequel::Model`).
+
+### Database guard
+
+A database guard is what you use to access a database handle. First, you need to instantiate one:
+```ruby
+::DB = Sequel::DatabaseGuard.new('postgres://localhost/mydb')
+```
+
+You can perform additional actions upon DB initialization, such as enabling Sequel plugins:
+```ruby
+::DB = Sequel::DatabaseGuard.new('postgres://localhost/mydb') do |db|
+  db.extension :advisory_locking
+  db.extension :pg_json
+end
+```
+
+There are two ways of using the guard.
+
+#### Safe access
+
+You can safely access the database handle by using `#safe_execute`:
+
+```ruby
+users = DB.safe_execute do
+  # if the database is reachable
+  alive do |db|
+    db[:users].all
+  end
+
+  # if the database could not be reached. NOTE: this is optional
+  dead do
+    []
+  end
+end
+```
+
+#### Unsafe access
+
+When you don't care about safety (or you're already inside a `safe_execute` context), use
+`#force_execute`:
+
+```ruby
+users = DB.force_execute { |db| db[:users].all }
+```
+
+#### Accessing a raw database handle
+
+Sometimes it's necessary to get access to a raw instance of `Sequel::Database` (for example, when
+using the `database_cleaner` gem). You can get a raw handle like this:
+
+```ruby
+DB.raw_handle
+```
+
+Beware that this will raise `Sequel::DatabaseConnectionError` if the database is currently
+unreachable.
+
+### Model guard
+
+A model guard is what you use to access a model handle. To create a model guard:
+```ruby
+# NOTE: `DB` must be an instance of Sequel::DatabaseGuard
+UserGuard = Sequel::ModelGuard(DB[:users]) do
+  one_to_many :cookies, class: 'Cookie::RawModel'
+
+  def admin?
+    role == 'admin'
+  end
+end
+```
+
+There are, again, two ways of using the guard.
+
+#### Safe access
+
+You can safely access the model by using `#safe_execute`:
+
+```ruby
+users = UserGuard.safe_execute do
+  # if the database is reachable
+  alive do |model|
+    model.all
+  end
+
+  # if the database could not be reached. NOTE: this is optional
+  dead do
+    []
+  end
+end
+```
+
+#### Unsafe access
+
+When you don't care about safety (or you're already inside a `safe_execute` context), use
+`#force_execute`:
+
+```ruby
+users = UserGuard.force_execute { |model| model.all }
+```
+
+#### Accessing a raw model
+
+Sometimes it's necessary to get access to a raw instance of `Sequel::Model` (good examples are
+using this extension with `factory_bot` and describing associations like shown above).
+To get the raw model:
+
+```ruby
+User = UserGuard::RawModel
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/umbrellio/sequel-connection_guard.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Authors
+Created by [Alexander Komarov](https://github.com/akxcv).
+
+<a href="https://github.com/umbrellio/">
+  <img style="float: left;" src="https://umbrellio.github.io/Umbrellio/supported_by_umbrellio.svg" alt="Supported by Umbrellio" width="439" height="72">
+</a>

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'sequel'
+
+Sequel.extension :connection_guard
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+

data/lib/sequel/extensions/connection_guard.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "sequel/extensions/connection_guard/configuration_error"
+require "sequel/extensions/connection_guard/connection_guard"
+require "sequel/extensions/connection_guard/database_guard"
+require "sequel/extensions/connection_guard/dataset"
+require "sequel/extensions/connection_guard/executor"
+require "sequel/extensions/connection_guard/model_guard"
+
+# @api public
+# @since 0.1.0
+module Sequel
+  # A constructor for model guards.
+  #
+  # @param ds [Sequel::ConnectionGuard::Dataset]
+  # @param class_body [Proc] Mimics Sequel::Model class body.
+  #
+  # @example Creating model guards
+  #   DB = Sequel::DatabaseGuard.new('postgres://localhost/mydb')
+  #
+  #   UserGuard = Sequel::ModelGuard(DB[:users]) do
+  #     many_to_one :cookies, class: 'CookieGuard::RawModel', key: :user_id
+  #
+  #     def admin?
+  #       role == 'admin'
+  #     end
+  #   end
+  #
+  #   CookieGuard = Sequel::ModelGuard(DB[:cookies])
+  #
+  # @example Safely accessing a model
+  #   users = UserGuard.safe_execute do
+  #     alive do |model|
+  #       model.all
+  #     end
+  #
+  #     dead do
+  #       []
+  #     end
+  #   end
+  #
+  # @example Unsafely accessing a model (raises an exception if connection fails)
+  #   cookies = UserGuard.force_execute { |model| model.first!(id: id).cookies }
+  #
+  # @api public
+  # @since 0.1.0
+  # rubocop:disable Naming/MethodName
+  def self.ModelGuard(ds, &class_body)
+    model = ConnectionGuard::ModelGuard.new(ds, &class_body)
+
+    Class.new.tap do |klass|
+      klass.define_singleton_method(:safe_execute) do |&block|
+        model.safe_execute(&block)
+      end
+
+      klass.define_singleton_method(:force_execute) do |&block|
+        model.force_execute(&block)
+      end
+
+      klass.define_singleton_method(:const_missing) do |const_name|
+        if const_name == :RawModel
+          model.raw_model
+        else
+          super(const_name)
+        end
+      end
+    end
+  end
+  # rubocop:enable Naming/MethodName
+
+  # @see Sequel::ConnectionGuard::DatabaseGuard
+  #
+  # @api public
+  # @since 0.1.0
+  DatabaseGuard = ConnectionGuard::DatabaseGuard
+
+  # @api public
+  # @since 0.1.0
+  module ConnectionGuard; end
+end

data/lib/sequel/extensions/connection_guard/configuration_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # @api public
+    # @since 0.1.0
+    ConfigurationError = Class.new(ArgumentError)
+  end
+end

data/lib/sequel/extensions/connection_guard/connection_guard.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # @api private
+    # @since 0.1.0
+    class ConnectionGuard
+      # @param config [String, Hash] database configuration
+      # @param initializer [Proc] code to run upon successful connection
+      #
+      # @api private
+      # @since 0.1.0
+      def initialize(config, &initializer)
+        @config = config
+        @initializer = initializer
+        @connection = nil
+
+        try_establish_connection
+      end
+
+      # @raise [Sequel::DatabaseConnectionError] connection failure
+      #
+      # @api private
+      # @since 0.1.0
+      def force_execute(&_block)
+        try_establish_connection if @connection.nil?
+        raise Sequel::DatabaseConnectionError unless connection_established?
+
+        yield @connection
+      end
+
+      # @raise [Sequel::DatabaseConnectionError] if connection is not established
+      #
+      # @api private
+      # @since 0.1.0
+      def raw_handle
+        try_establish_connection if @connection.nil?
+
+        return @connection if connection_established?
+        raise Sequel::DatabaseConnectionError
+      end
+
+      private
+
+      # @return [void]
+      #
+      # @api private
+      # @since 0.1.0
+      def try_establish_connection
+        @connection = Sequel.connect(@config)
+        @initializer&.call(@connection)
+      rescue Sequel::DatabaseConnectionError
+      end
+
+      # @return [bool]
+      #
+      # @api private
+      # @since 0.1.0
+      def connection_established?
+        return false if @connection.nil?
+        @connection.test_connection
+      rescue Sequel::Error
+        false
+      end
+    end
+  end
+end

data/lib/sequel/extensions/connection_guard/database_guard.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # An abstraction for safely accessing Sequel models.
+    #
+    # @example Creating a database guard
+    #   DB = Sequel::DatabaseGuard.new('postgres://localhost/mydb')
+    #
+    # @example Safely accessing the database
+    #   users = DB.safe_execute do
+    #     alive do |db|
+    #       db[:users].all
+    #     end
+    #
+    #     dead do
+    #       []
+    #     end
+    #   end
+    #
+    # @example Unsafely accessing the database (raises an exception if connection fails)
+    #   DB.force_execute { |db| db[:users].insert(email: 'billikota@example.com', role: 'admin') }
+    #
+    # @api public
+    # @since 0.1.0
+    class DatabaseGuard
+      # @param config [String, Hash] database configuration
+      # @param initializer [Proc] code to run upon successful connection
+      #
+      # @api public
+      # @since 0.1.0
+      def initialize(config, &initializer)
+        @connection_guard = ConnectionGuard.new(config, &initializer)
+      end
+
+      # Safely access the database.
+      #
+      # @example
+      #   users = DB.safe_execute do
+      #     alive { |db| db[:users].all }
+      #     dead { [] }
+      #   end
+      #
+      # @param block [Proc]
+      #
+      # @api public
+      # @since 0.1.0
+      def safe_execute(&block)
+        executor = Executor.new
+        executor.instance_eval(&block)
+        @connection_guard.force_execute(&executor.on_alive)
+      rescue Sequel::DatabaseConnectionError
+        executor.on_dead&.call
+      end
+
+      # Unsafely access the database. Will fail if connection fails.
+      #
+      # @example
+      #   DB.force_execute { |db| db[:users].insert(email: 'rustam@example.com') }
+      #
+      # @param block [Proc]
+      # @raise [Sequel::DatabaseConnectionError] connection failure
+      #
+      # @api public
+      # @since 0.1.0
+      def force_execute(&block)
+        @connection_guard.force_execute(&block)
+      end
+
+      # A raw connection handle. Intended for use in test environments (e.x. with DatabaseCleaner)
+      #
+      # @raise [Sequel::DatabaseConnectionError] if connection is not established
+      #
+      # @api public
+      # @since 0.1.0
+      def raw_handle
+        @connection_guard.raw_handle
+      end
+
+      # @param table_name [Symbol]
+      # @return [Sequel::ConnectionGuard::Dataset]
+      #
+      # @api private
+      # @since 0.1.0
+      def [](table_name)
+        Dataset.new(@connection_guard, table_name)
+      end
+
+      # @return [void]
+      #
+      # @api private
+      # @since 0.1.0
+      def disconnect
+        @connection_guard.force_execute(&:disconnect)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/connection_guard/dataset.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # A value object that stores all the information required to construct a Sequel dataset.
+    #
+    # @api private
+    # @since 0.1.0
+    class Dataset
+      # @api private
+      # @since 0.1.0
+      attr_reader :connection_guard, :table_name
+
+      # @param connection_guard [Sequel::ConnectionGuard::ConnectionGuard]
+      # @param table_name [Symbol]
+      #
+      # @api private
+      # @since 0.1.0
+      def initialize(connection_guard, table_name)
+        @connection_guard = connection_guard
+        @table_name = table_name
+      end
+    end
+  end
+end

data/lib/sequel/extensions/connection_guard/executor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # Provides a DSL for accessing the database safely.
+    #
+    # @example Safely accessing a database
+    #   DB.safe_execute do
+    #     alive do |db|
+    #       db[:users].all
+    #     end
+    #
+    #     dead do
+    #       []
+    #     end
+    #   end
+    #
+    # @example Safely accessing a model
+    #   UserGuard.safe_execute do
+    #     alive do |model|
+    #       model.first!
+    #     end
+    #
+    #     # `dead` handler is optional
+    #   end
+    #
+    # @api private
+    # @since 0.1.0
+    class Executor
+      # @api private
+      # @since 0.1.0
+      attr_reader :on_dead
+
+      # @param block [Proc]
+      #
+      # @api private
+      # @since 0.1.0
+      def alive(&block)
+        @on_alive = block
+      end
+
+      # @param block [Proc]
+      #
+      # @api private
+      # @since 0.1.0
+      def dead(&block)
+        @on_dead = block
+      end
+
+      # @raise [Sequel::ConnectionGuard::ConfigurationError] if an `alive` handler is missing
+      #
+      # @api private
+      # @since 0.1.0
+      def on_alive
+        raise ConfigurationError, "`alive` handler is required for .safe_execute" if @on_alive.nil?
+        @on_alive
+      end
+    end
+  end
+end

data/lib/sequel/extensions/connection_guard/model_guard.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Sequel
+  module ConnectionGuard
+    # An abstraction for safely accessing Sequel models.
+    #
+    # @see Sequel.ModelGuard
+    #
+    # @api public
+    # @since 0.1.0
+    class ModelGuard
+      # @param ds [Sequel::ConnectionGuard::Dataset]
+      # @option class_body [Proc]
+      #
+      # @api private
+      # @since 0.1.0
+      def initialize(ds, &class_body)
+        @connection_guard = ds.connection_guard
+        @table_name = ds.table_name
+        @class_body = class_body
+        @connected = false
+        @model = nil
+      end
+
+      # Safely access the model.
+      #
+      # @example
+      #   users = UserGuard.safe_execute do
+      #     alive { |model| model.all }
+      #     dead { [] }
+      #   end
+      #
+      # @param block [Proc]
+      #
+      # @api public
+      # @since 0.1.0
+      def safe_execute(&block)
+        executor = Executor.new
+        executor.instance_eval(&block)
+
+        @connection_guard.force_execute do |connection|
+          instantiate_model(connection) unless @connected
+
+          executor.on_alive.call(@model)
+        end
+      rescue Sequel::DatabaseConnectionError
+        @connected = false
+
+        executor.on_dead&.call
+      end
+
+      # Unsafely access the model. Will fail if connection fails.
+      #
+      # @example
+      #   UserGuard.force_execute { |model| model.create(email: 'vova@example.com') }
+      #
+      # @param block [Proc]
+      # @raise [Sequel::DatabaseConnectionError] connection failure
+      #
+      # @api public
+      # @since 0.1.0
+      def force_execute(&block)
+        @connection_guard.force_execute do |connection|
+          instantiate_model(connection) unless @connected
+
+          yield @model
+        end
+      rescue Sequel::DatabaseConnectionError => error
+        @connected = false
+        raise error
+      end
+
+      # @api private
+      # @since 0.1.0
+      def raw_model
+        try_instantiate_model if @model.nil?
+        @model
+      end
+
+      private
+
+      # @raise [Sequel::DatabaseConnectionError] connection failure
+      #
+      # @api private
+      # @since 0.1.0
+      def instantiate_model(connection)
+        if @model.nil?
+          @model = Class.new(Sequel::Model(connection[@table_name]))
+          @model.class_eval(&@class_body) unless @class_body.nil?
+        else
+          @model.dataset = connection[@table_name]
+        end
+
+        @connected = true
+      end
+
+      # @api private
+      # @since 0.1.0
+      def try_instantiate_model
+        @connection_guard.force_execute { |connection| instantiate_model(connection) }
+      rescue Sequel::DatabaseConnectionError
+      end
+    end
+  end
+end

data/sequel-connection_guard.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.required_ruby_version = ">= 2.5.1"
+
+  spec.name          = "sequel-connection_guard"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Alexander Komarov"]
+  spec.email         = %w[ak@akxcv.com oss@umbrellio.biz]
+
+  spec.summary       = "A set of tools for working with unreliable databases."
+  spec.description   = "Provides an abstraction for working with unreliable databases safely."
+  spec.homepage      = "https://github.com/umbrellio/sequel-connection_guard"
+  spec.license       = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.require_paths = %w[lib]
+
+  spec.add_dependency "sequel", "> 5.5"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "armitage-rubocop", "~> 0.33"
+  spec.add_development_dependency "rubocop-config-umbrellio", "~> 0.70.0"
+  spec.add_development_dependency "pg", "~> 1.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "coveralls", "~> 0.8"
+  spec.add_development_dependency "simplecov", "~> 0.16"
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: sequel-connection_guard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Komarov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: armitage-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.33'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.33'
+- !ruby/object:Gem::Dependency
+  name: rubocop-config-umbrellio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.70.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.70.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: Provides an abstraction for working with unreliable databases safely.
+email:
+- ak@akxcv.com
+- oss@umbrellio.biz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sequel/extensions/connection_guard.rb
+- lib/sequel/extensions/connection_guard/configuration_error.rb
+- lib/sequel/extensions/connection_guard/connection_guard.rb
+- lib/sequel/extensions/connection_guard/database_guard.rb
+- lib/sequel/extensions/connection_guard/dataset.rb
+- lib/sequel/extensions/connection_guard/executor.rb
+- lib/sequel/extensions/connection_guard/model_guard.rb
+- sequel-connection_guard.gemspec
+homepage: https://github.com/umbrellio/sequel-connection_guard
+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.5.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A set of tools for working with unreliable databases.
+test_files: []