dba 1.0.0

data/README.md

@@ -0,0 +1,40 @@
+# dba
+
+A developer tool for working with development databases.
+
+
+## Installation
+
+    $ gem install dba
+
+Note: you may also need to install the pg, mysql2, or sqlite3 gems unless you
+already have them in your environment.
+
+You can connect to any database supported by [sequel](https://rubygems.org/gems/sequel).
+
+
+## Usage
+
+    $ dba
+    Usage: dba COMMAND
+
+      dba diff URL
+      dba edit TABLE IDENTIFIER
+      dba find TABLE IDENTIFIER
+      dba indexes [TABLE]
+      dba pull TABLE URL
+      dba sample TABLE [COLUMN]
+      dba schema [TABLE]
+      dba tables 
+
+
+## ERROR: could not find database
+
+In order to determine which database to connect to dba checks `.env` for a
+`DATABASE_URL` variable, `config/database.yml` for your Rails development
+database config, postgres on localhost (if it's running), and the current
+working directory for any `.sqlite3` files.
+
+If your development database does not match any of these criteria please
+open a pull request or issue describing your development database setup,
+but first make sure you're running the command from the correct directory.

data/bin/dba

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'dba'
+
+DBA::Shell.run

data/dba.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = 'dba'
+  s.version = '1.0.0'
+  s.license = 'GPL-3.0'
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Tim Craft']
+  s.email = ['mail@timcraft.com']
+  s.homepage = 'https://github.com/readysteady/dba'
+  s.description = 'A developer tool for working with development databases'
+  s.summary = 'See description'
+  s.files = Dir.glob('lib/**/*.rb') + %w[LICENSE.txt README.md dba.gemspec]
+  s.required_ruby_version = '>= 2.3.0'
+  s.add_dependency('zeitwerk', '~> 2', '>= 2.2')
+  s.add_dependency('sequel', '~> 5')
+  s.add_dependency('pastel', '~> 0')
+  s.require_path = 'lib'
+  s.executables = ['dba']
+end

data/lib/dba.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2019 TIMCRAFT
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+require 'zeitwerk'
+
+module DBA
+  Error = Class.new(StandardError)
+
+  loader = Zeitwerk::Loader.new
+  loader.tag = File.basename(__FILE__, '.rb')
+  loader.inflector.inflect('dba' => 'DBA')
+  loader.push_dir(__dir__)
+  loader.setup
+end

data/lib/dba/command.rb

@@ -0,0 +1,23 @@
+class DBA::Command
+  def initialize(database)
+    self.database = database
+  end
+
+  attr_accessor :database
+
+  attr_reader :table_name
+
+  def table_name=(table_name)
+    @table_name = table_name.to_sym
+
+    unless database.tables.include?(@table_name)
+      raise DBA::Error, "could not find table #{table_name}"
+    end
+  end
+
+  private
+
+  def printer
+    @printer ||= DBA::Printer.new
+  end
+end

data/lib/dba/database.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'yaml'
+require 'erb'
+
+module DBA::Database
+  extend self
+
+  def connect
+    args = find_connection_args
+
+    Sequel.connect(args)
+  rescue Sequel::DatabaseConnectionError => exception
+    raise DBA::Error, connection_error_message(args)
+  end
+
+  private
+
+  def find_connection_args
+    if dotenv?
+      File.readlines('.env').each do |line|
+        if line.strip =~ /\ADATABASE_URL=/
+          return $'
+        end
+      end
+    end
+
+    if database_config?
+      return development_database_args
+    end
+
+    if postgres_running?
+      return "postgres://localhost:5432/#{postgres_database_name}"
+    end
+
+    if path = Dir['*.sqlite3'].first
+      return 'sqlite://' + path
+    end
+
+    raise DBA::Error, 'could not find database'
+  end
+
+  def connection_error_message(args)
+    if args.is_a?(Hash)
+      adapter, host, port = args.values_at('adapter', 'host', 'port')
+
+      host ||= 'localhost'
+
+      if port
+        "could not connect to #{adapter} database at #{host}:#{port}"
+      else
+        "could not connect to #{adapter} database at #{host}"
+      end
+    else
+      uri = URI(args)
+
+      "could not connect to #{uri.scheme} database at #{uri.host}"
+    end
+  end
+
+  def dotenv?
+    File.exist?('.env')
+  end
+
+  def database_config?
+    File.exist?('config/database.yml')
+  end
+
+  def database_config
+    YAML.load(ERB.new(File.read('config/database.yml')).result)
+  end
+
+  def development_database_args
+    args = database_config['development']
+    args['adapter'] = 'postgres' if args['adapter'] == 'postgresql'
+    args['adapter'] = 'sqlite' if args['adapter'] == 'sqlite3'
+    args
+  end
+
+  def postgres_database_name
+    heroku_app_name || working_directory_name
+  end
+
+  def heroku_app_name
+    if `git config --get remote.heroku.url`.chomp =~ %r{(?<=[:/])([^:/]+)\.git\z}
+      $1
+    end
+  end
+
+  def working_directory_name
+    File.basename(Dir.pwd)
+  end
+
+  def postgres_running?
+    !`lsof -i:5432`.strip.empty?
+  end
+end

data/lib/dba/diff.rb

@@ -0,0 +1,43 @@
+require 'sequel'
+
+class DBA::Diff < DBA::Command
+  def call(url)
+    other_database = Sequel.connect(url)
+
+    tables = database.tables
+
+    other_tables = other_database.tables
+
+    diff tables, other_tables
+
+    tables &= other_tables # only diff columns/indexes for tables that exist in both databases
+
+    printer.print_diff list_columns(database, tables), list_columns(other_database, tables)
+
+    printer.print_diff list_indexes(database, tables), list_indexes(other_database, tables)
+  end
+
+  private
+
+  def list_columns(database, tables)
+    tables.inject([]) do |columns, table_name|
+      columns + database.schema(table_name).map { |name, info| format_column(name, info) }
+    end
+  end
+
+  def list_indexes(database, tables)
+    tables.inject([]) do |indexes, table_name|
+      indexes + database.indexes(table_name).map { |name, info| format_index(name, info) }
+    end
+  end
+
+  def format_column(name, info_hash)
+    "#{table_name}.#{name} (#{info_hash.fetch(:type)})"
+  end
+
+  def format_index(name, info_hash)
+    columns = info_hash.fetch(:columns).map(&:to_s).join(', ')
+
+    "#{name} (#{columns})"
+  end
+end

data/lib/dba/edit.rb

@@ -0,0 +1,34 @@
+require 'logger'
+require 'time'
+
+class DBA::Edit < DBA::RowCommand
+  def call(table, identifier)
+    super
+
+    row_parser = DBA::RowParser.new(table_schema)
+
+    row_editor = DBA::RowEditor.new(row_parser)
+
+    attributes = row_editor.edit(row)
+
+    attributes.each do |key, value|
+      attributes.delete(key) if equal?(value, row[key])
+    end
+
+    return if attributes.empty?
+
+    database.loggers << Logger.new(STDOUT)
+
+    dataset.update(attributes)
+  end
+
+  private
+
+  def equal?(a, b)
+    # A parsed Time and a database stored Time might be different if
+    # the database stored Time has a non-zero millisecond component.
+    return a.to_s == b.to_s if a.is_a?(Time) && b.is_a?(Time)
+
+    a == b
+  end
+end

data/lib/dba/find.rb

@@ -0,0 +1,8 @@
+class DBA::Find < DBA::RowCommand
+  def call(table, identifier)
+    super
+
+    printer.print(row)
+    printer.print_line
+  end
+end

data/lib/dba/indexes.rb

@@ -0,0 +1,5 @@
+class DBA::Indexes < DBA::TableCommand
+  def visit(table_name)
+    printer.print_indexes(database.indexes(table_name))
+  end
+end

data/lib/dba/printer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'bigdecimal'
+
+class DBA::Printer
+  def initialize(io = STDOUT)
+    @io = io
+  end
+
+  attr_reader :io
+
+  def print_line
+    io.puts
+  end
+
+  def print_error(message)
+    io.puts(pastel.red('ERROR: ' + message))
+  end
+
+  def print_row(hash)
+    hash.each do |name, value|
+      io.puts muted("#{name}: ") + format(value)
+    end
+  end
+
+  alias_method :print, :print_row
+
+  def print_usage(program_name, command_parameters)
+    io.puts "Usage: #{program_name} COMMAND"
+    io.puts
+
+    command_parameters.each do |command_name, parameters|
+      parameters = parameters.map { |type, name| format_parameter(type, name) }.compact.join(' ').upcase
+
+      io.puts "  #{program_name} #{command_name} #{parameters}"
+    end
+
+    io.puts
+  end
+
+  def print_diff(before_lines, after_lines)
+    removed = before_lines - after_lines
+    removed.each { |line| io.puts pastel.red("- #{line}") }
+
+    added = after_lines - before_lines
+    added.each { |line| io.puts pastel.bright_black("+ #{line}") }
+  end
+
+  def print_table(name, row_count)
+    rows = muted("#{row_count} rows")
+
+    io.puts "#{name} #{rows}"
+  end
+
+  def print_schema(table_name, schema_hash)
+    schema_hash.each do |column_name, info_hash|
+      fields = []
+      fields << "#{table_name}.#{column_name}"
+      fields << muted(info_hash[:type] || info_hash[:db_type])
+      fields << muted('(primary key)') if info_hash[:primary_key]
+
+      io.puts fields.join(' ')
+    end
+
+    io.puts
+  end
+
+  def print_indexes(indexes)
+    indexes.each do |index_name, info_hash|
+      columns = info_hash.fetch(:columns).map(&:to_s).join(', ')
+
+      io.puts "#{index_name} (#{columns})"
+    end
+  end
+
+  private
+
+  def format(value)
+    case value
+    when NilClass
+      null
+    when BigDecimal
+      value.to_s('F')
+    when Time
+      value.strftime('%F %T')
+    else
+      value.to_s
+    end
+  end
+
+  def format_parameter(type, name)
+    case type
+    when :req then name
+    when :opt then "[#{name}]"
+    end
+  end
+
+  def null
+    @null ||= muted('NULL')
+  end
+
+  def muted(text)
+    return text unless io.isatty
+
+    pastel.bright_black(text.to_s)
+  end
+
+  def pastel
+    @pastel ||= Pastel.new
+  end
+end

data/lib/dba/pull.rb

@@ -0,0 +1,13 @@
+class DBA::Pull < DBA::Command
+  def call(table, url)
+    self.table_name = table
+
+    dataset = database[table_name]
+
+    other_database = Sequel.connect(url)
+
+    database.transaction do
+      other_database[table_name].each { |row| dataset.insert(row) }
+    end
+  end
+end

data/lib/dba/row_command.rb

@@ -0,0 +1,35 @@
+class DBA::RowCommand < DBA::Command
+  def call(table, identifier)
+    self.table_name = table
+
+    self.table_schema = DBA::TableSchema.new(database, table_name)
+
+    self.primary_key = table_schema.primary_key
+
+    self.dataset = database[table_name].where(primary_key => identifier)
+
+    self.row = dataset.first
+
+    unless row
+      raise DBA::Error, "could not find row #{primary_key}=#{identifier}"
+    end
+  end
+
+  private
+
+  attr_accessor :table_schema
+
+  attr_reader :primary_key
+
+  def primary_key=(primary_key)
+    unless primary_key
+      raise DBA::Error, "could not find primary key for #{table_name} table"
+    end
+
+    @primary_key = primary_key
+  end
+
+  attr_accessor :dataset
+
+  attr_accessor :row
+end