dbx 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ee3e7675d2bf79eee5b1c193719713b894677e6
+  data.tar.gz: a8c1b1a08b82a0ae18930b5d7e9614f5b0f2ee05
+SHA512:
+  metadata.gz: f0bbf5e27d8bf10dc4864c30c2bfbeb568c7815ec5f51f02e1a0c2a5673ccb1e7c0fb9e5a9e7a4e3ee70594b3a2bf19369c4e091d0426b21b727d6b38f2ebb19
+  data.tar.gz: 6b632abac4bb5546651d6825e5e209933a602901abf6785c59266c1a01c51e6e5f3b8e5ea43d6e64946046abf61777ea78284dff3d11296a0453b060ffcfb484

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+dbx.yml

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in dbx.gemspec
+gemspec
+
+group :development do
+  gem 'pg', '< 1.0.0'
+  gem 'pry'
+end

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    dbx (0.1.0)
+      activerecord (~> 4.0)
+      activesupport (~> 4.0)
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.10)
+      activesupport (= 4.2.10)
+      builder (~> 3.1)
+    activerecord (4.2.10)
+      activemodel (= 4.2.10)
+      activesupport (= 4.2.10)
+      arel (~> 6.0)
+    activesupport (4.2.10)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.4)
+    builder (3.2.3)
+    coderay (1.1.2)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    minitest (5.11.3)
+    pg (0.19.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  dbx!
+  pg (< 1.0.0)
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Scott Pierce
+
+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,67 @@
+# DBX
+
+Database eXtras for working with CSV files in a database.
+
+## Commands
+
+```sh
+Commands:
+  dbx create SRC               # create a table with types from SRC CSV file
+  dbx diff TABLE_A TABLE_B     # create diff table between TABLE_A and TABLE_B.
+  dbx help [COMMAND]           # Describe available commands or one specific command
+  dbx import SRC               # import SRC CSV into table
+  dbx import_diff SRC_A SRC_B  # import then diff between SRC_A CSV and SRC_B CSV files.
+  dbx types SRC                # detect column types give a SRC CSV file
+
+Options:
+  [--db=Database URL: adapter://user:pass@host:port/db_name]
+  [--column-patterns=List of column patterns to override type info. Ex: phone:string external_ref:string ...]
+  [--sample=Number of rows to sample for type detection] # Default: 100
+```
+
+## Configuration
+
+If the current path contains a `dbx.yml` file, it will be read first. Settings in the config file can still be overridden by command line arguments.
+
+```yaml
+# Column patterns are used to override column detection based on the a matched pattern in the name.
+# This is useful for things like phone numbers and zip codes where they look like numbers, but should be strings.
+column_patterns:
+  phone_number: :string
+  zipcode:      :string
+  zip_code:     :string
+  external_ref: :string
+
+# Number of rows to sample for type detection
+sample: 100
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dbx'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dbx
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ddrscott/dbx.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'dbx'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dbx.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dbx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dbx'
+  spec.version       = Dbx::VERSION
+  spec.authors       = ['Scott Pierce']
+  spec.email         = ['ddrscott@gmail.com']
+
+  spec.summary       = 'Database utilities'
+  spec.homepage      = 'https://github.com/ddrscott/dbx'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.add_dependency 'activerecord', '~> 4.0'
+  spec.add_dependency 'activesupport', '~> 4.0'
+  spec.add_dependency 'thor'
+end

data/dbx_sample.yml

@@ -0,0 +1,3 @@
+column_patterns:
+  phone_number: :string
+  external: :string

data/exe/dbx

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'thor'
+require 'dbx'
+require 'pp'
+require 'pry'
+
+# nodoc
+# #rubocop:disable all
+class CLI < Thor
+  class_option :db, type: :string, banner: 'Database URL: adapter://user:pass@host:port/db_name'
+  class_option :column_patterns, type: :array, banner: 'List of column patterns to override type info. Ex: phone:string external_ref:string ...'
+  class_option :sample, type: :numeric, banner: 'Number of rows to sample for type detection', default: 100
+
+  # contents of the Thor class
+  desc 'types SRC', 'detect column types give a SRC CSV file'
+  def types(src)
+    handle_global_options
+    DBX.column_types(src, sample_rows: options[:sample]).each do |col, type|
+      puts "#{col},#{type}"
+    end
+  end
+
+  desc 'create SRC', 'create a table with types from SRC CSV file'
+  option :name
+  option :force, type: :boolean
+  def create(src)
+    handle_global_options
+    DBX.create_table(
+      src,
+      name: options[:name],
+      force: options[:force]
+    )
+  end
+
+  desc 'import SRC', 'import SRC CSV into table'
+  option :name
+  option :force, type: :boolean
+  def import(src)
+    handle_global_options
+    DBX.import_table(
+      src,
+      name: options[:name],
+      force: options[:force]
+    )
+  end
+
+  desc 'diff TABLE_A TABLE_B', 'create diff table between TABLE_A and TABLE_B.'
+  option :force, type: :boolean, banner: 'remove diff_ table if it exists'
+  option :using, type: :array, banner: 'JOIN USING the columns list here. Ex: id'
+  option :exclude_columns, type: :array, banner: 'Exclude columns from comparison and selection'
+  def diff(table_a, table_b)
+    handle_global_options
+    DBX::Differ.diff(
+      table_a: table_a,
+      table_b: table_b,
+      using: options[:using],
+      exclude_columns: options[:exclude_columns],
+      force: options[:force]
+    )
+  end
+
+  desc 'import_diff SRC_A SRC_B', 'import then diff between SRC_A CSV and SRC_B CSV files.'
+  option :force, type: :boolean, banner: 'remove diff_ table if it exists'
+  option :using, type: :array, banner: 'JOIN USING the columns list here. Ex: id'
+  option :exclude_columns, type: :array, banner: 'Exclude columns from comparison and selection'
+  def import_diff(src_a, src_b)
+    handle_global_options
+    DBX::Differ.import_and_diff(
+      src_a: src_a,
+      src_b: src_b,
+      using: options[:using],
+      exclude_columns: options[:exclude_columns],
+      force: options[:force]
+    )
+  end
+
+  private
+
+  def handle_global_options
+    if options[:column_patterns]
+      options[:column_patterns].each do |pair|
+        pattern, type = pair.split(':').map(&:strip)
+        patterns = (DBX.config['column_patterns'] ||= {})
+        patterns[pattern] = type.to_sym
+      end
+    end
+
+    if options[:sample]
+      DBX.config['sample_rows'] = options[:sample]
+    end
+
+    if options[:db]
+      DBX.config['db'] = options[:db]
+    end
+  end
+end
+CLI.start(ARGV)

data/lib/dbx/differ.rb

@@ -0,0 +1,100 @@
+# #rubocop:disable all
+module DBX
+  module Differ
+    module_function
+
+    # Compare `src_a` with `src_b`.
+    # Numeric types will be diffed by subtracting the values.
+    # Dates will contain difference by day.
+    # Datetime will contain difference by seconds.
+    # Everything else can only return a boolean true/false that it is different.
+    #
+    # @param [String] table A Should be the initial state table.
+    # @param [String] table B Should be newer than table A, but doesn't have to be.
+    # @param [Array<String>] using is the join criteria between the 2 tables.
+    # @param [Array<String>] exclude_columns are excluded from the diff comparison.
+    def diff(table_a:, table_b:, force: false, using: ['id'], exclude_columns: nil)
+      table_diff = "diff_#{table_a}_#{table_b}"
+      exclude_columns ||= []
+      DBX.info("Creating diff table #{table_diff}")
+      DBX.connection do |conn|
+        conn.execute("DROP TABLE IF EXISTS #{table_diff}") if force
+        conn.execute(<<-SQL)
+        CREATE TABLE #{table_diff} AS
+        SELECT
+          #{using.join(', ')},
+          #{select_columns(table_a, exclude_columns: using + exclude_columns)}
+        FROM #{table_a} AS a
+        FULL OUTER JOIN #{table_b} b USING (#{using.join(',')})
+        WHERE
+          #{where_columns(table_a, exclude_columns: using + exclude_columns)}
+        SQL
+        DBX.info(conn.exec_query(<<-SQL).as_json)
+        SELECT
+          (SELECT COUNT(*) FROM #{table_a}) count_table_a,
+          (SELECT COUNT(*) FROM #{table_b}) count_table_b,
+          (SELECT COUNT(*) FROM #{table_diff}) diffs
+        SQL
+      end
+      DBX.info("Diff complete. Results details in:   #{table_diff}")
+    end
+
+    def import_and_diff(src_a:, src_b:, force: false, using: ['id'], exclude_columns: nil)
+      DBX.info("Importing #{src_a}")
+      table_a = DBX.import_table(src_a, force: force)
+
+
+      DBX.info("Importing #{src_b}")
+      table_b = DBX.import_table(src_b, force: force)
+
+      diff(table_a: table_a, table_b: table_b, force: force, using: using, exclude_columns: exclude_columns)
+    end
+
+    def select_columns(table, exclude_columns: nil)
+      exclude_columns ||= []
+      DBX.connection do |conn|
+        conn.columns(table).map do |column|
+          header, type = column.name, column.type
+          next if exclude_columns.include?(header)
+          case type
+          when :decimal, :integer
+            select_difference(header)
+          when :date, :datetime
+            select_difference_as_text(header)
+          else
+            select_boolean(header)
+          end
+        end.compact.join(',')
+      end
+    end
+
+    def where_columns(table, exclude_columns: nil)
+      exclude_columns ||= []
+      DBX.connection do |conn|
+        conn.columns(table).map do |column|
+          header, type = column.name, column.type
+          next if exclude_columns.include?(header)
+          %((a.#{header} <> b.#{header}))
+        end
+      end.compact.join('OR')
+    end
+
+    def select_difference(column)
+      a = "a.#{column}"
+      b = "b.#{column}"
+      %(#{a} AS #{column}_a, #{b} AS #{column}_b, (CASE WHEN #{a} IS NULL THEN #{b} WHEN #{b} IS NULL THEN #{a} ELSE NULLIF(#{b} - #{a}, 0) END) AS #{column}_diff)
+    end
+
+    def select_difference_as_text(column)
+      a = "a.#{column}"
+      b = "b.#{column}"
+      %(#{a} AS #{column}_a, #{b} AS #{column}_b, (CASE WHEN #{a} IS NULL THEN #{b}::text WHEN #{b} IS NULL THEN #{a}::text ELSE NULLIF((#{b} - #{a})::text, '0') END) AS #{column}_diff)
+    end
+
+    def select_boolean(column)
+      a = "a.#{column}"
+      b = "b.#{column}"
+      %(#{a} AS #{column}_a, #{b} AS #{column}_b, NULLIF(#{a} <> #{b}, FALSE) AS #{column}_diff)
+    end
+  end
+end

data/lib/dbx/model_base.rb

@@ -0,0 +1,5 @@
+module DBX
+  class ModelBase < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/lib/dbx/version.rb

@@ -0,0 +1,3 @@
+module Dbx
+  VERSION = '0.1.0'.freeze
+end

data/lib/dbx.rb

@@ -0,0 +1,178 @@
+require 'dbx/version'
+require 'yaml'
+require 'csv'
+require 'pg'
+require 'active_support/all'
+require 'active_record'
+require 'pp'
+
+require 'dbx/model_base'
+require 'dbx/differ'
+
+# Collection of database utility methods
+#
+# #rubocop:disable all
+module DBX
+  module_function
+
+  CONFIG_PATH = 'dbx.yml'
+
+  def config
+    @config ||= config_from_yaml
+  end
+
+  def config_from_yaml
+    if File.file?(CONFIG_PATH)
+      YAML.load(IO.read(CONFIG_PATH))
+    else
+      {}
+    end
+  end
+
+  def config_sample_rows
+    config['sample_rows'] || 100
+  end
+
+  def config_db
+    ENV['DATABASE_URL'] || config['db'] || raise('`db` not set as command line option or `dbx.yml`')
+  end
+
+  # TODO what about windows?!
+  def tty
+    @tty ||= File.open('/dev/tty', 'a')
+  end
+
+  def info(msg)
+    tty.puts("\e[33m#{msg}\e[0m")
+  end
+
+  def connection(db_url: config_db, &block)
+    # ENV['DATABASE_URL'] = db_url
+    # @pool ||= ModelBase.establish_connection(db_url)
+    @pool ||= begin
+      ModelBase.establish_connection(db_url)
+      ModelBase.logger = Logger.new(tty)
+    end
+    ModelBase.connection_pool.with_connection(&block)
+  end
+
+  def parse_table_name(src)
+    File.basename(src).sub(File.extname(src), '')
+  end
+
+  def create_table(src, name: nil, force: false, sample_rows: config_sample_rows, csv_options: {})
+    name ||= parse_table_name(src)
+    types = column_types(src, sample_rows: sample_rows, csv_options: csv_options)
+    connection do |conn|
+      conn.create_table name, force: force, id: false do |t|
+        types.each do |column, type|
+          t.send(type, column, nulls: true)
+        end
+      end
+    end
+  end
+
+  # TODO parse CSV options into Postgres
+  def import_table(src, name: nil, force: false, sample_rows: config_sample_rows, csv_options: {})
+    name ||= parse_table_name(src)
+    connection do |conn|
+      create_table(src, force: force, sample_rows: sample_rows, csv_options: csv_options)
+      # TODO only postgres is support at the moment
+      pg = conn.instance_variable_get(:@connection)
+      types = column_types(src).keys.map{|m| %("#{m}")}
+
+      pg_stmt = "COPY #{name}(#{types.join(',')}) FROM STDIN CSV"
+      conn.logger.debug(pg_stmt)
+      pg.copy_data(pg_stmt) do
+        first = true
+        IO.foreach(src) do |line|
+          if first
+            first = false
+            next
+          end
+          pg.put_copy_data(line)
+        end
+      end
+      index_table(name)
+    end
+    name
+  end
+
+  def index_table(table_name)
+    connection do |conn|
+      conn.columns(table_name).each_with_index do |column, i|
+        conn.add_index(table_name, [column.name], name: "idx_#{table_name}_#{i.to_s.rjust(2,'0')}")
+      end
+    end
+  end
+
+  # Read source as CSV and detect types based on `sample_rows`
+  # Types returns match with ActiveRecord column types.
+  # Types are memory cached by `src`.
+  #
+  # @return [Hash<String, Symbol>] column name to type symbols
+  def column_types(src, sample_rows: config_sample_rows, csv_options: {})
+    headers = nil
+    count = 0
+    csv_options[:headers] = false
+    @types ||= {}
+
+    types = @types[src]
+    return types if types
+    types = []
+
+    CSV.foreach(src, **csv_options) do |row|
+      unless headers
+        headers = row
+        next
+      end
+
+      headers.each_with_index do |header, i|
+        next if types[i] == :string
+
+        pattern_type = config['column_patterns'].detect{ |pat, _| header =~ /#{pat}/ }
+        if pattern_type
+          types[i] = pattern_type.last
+          next
+        end
+
+        type = detect_type(row[i])
+        next if type.nil?
+        if types[i] == :decimal && type == :integer
+          # keep decimal
+        elsif types[i] == :datetime && type == :date
+          # keep datetime
+        else
+          # assign the new type
+          types[i] = type
+        end
+      end
+      # stop after max rows reached
+      break if (count += 1) > sample_rows
+    end
+    # any remaining nil types are assigned as :string
+    types.size.times{|i| types[i] ||= :string }
+    @types[src] = Hash[headers.zip(types)]
+  end
+
+  # Detect the column type given a value.
+  # May return nil if the value is blank.
+  def detect_type(value)
+    if value.blank?
+      nil
+    elsif value =~ /^\d+\.\d+$/
+      :decimal
+    elsif value =~ /^\d{1,10}$/
+      :integer
+    elsif value =~ /^\h{8}-\h{4}-\h{4}-\h{4}-\h{12}$/
+      :uuid
+    elsif value =~ /^\d{4}(\D)\d{2}\1\d{2}$/ && (Date.parse(value) rescue false)
+      :date
+    elsif (Time.zone.parse(value) rescue false)
+      :datetime
+    else
+      :string
+    end
+  end
+end
+# #rubocop:enable all

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: dbx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scott Pierce
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ddrscott@gmail.com
+executables:
+- dbx
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dbx.gemspec
+- dbx_sample.yml
+- exe/dbx
+- lib/dbx.rb
+- lib/dbx/differ.rb
+- lib/dbx/model_base.rb
+- lib/dbx/version.rb
+homepage: https://github.com/ddrscott/dbx
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Database utilities
+test_files: []