pgdice 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63a62f8196d2f0299a6e181001c2f1c34020683360d01347a24288a9da0bc16a
-  data.tar.gz: 2a6edd7716f95f215a222b9d47bfdae2897852c70cfff516767ab4669c167872
+  metadata.gz: fda4fee4feb3b2d3dd02baa31b524cf14e6047a9c915bc45c9c8abc5f056361a
+  data.tar.gz: 5d12a5c07ebdc686a85d32a567af90c7fa38c98c70cd0ee7986ae70bdaf9a1ce
 SHA512:
-  metadata.gz: 190c116e139dce2e6e009703be2b38eea7a7d51efb0ebf01266abf63005e1122d55569b49d65a56dc5ce1173392e2fe24fa5cc77c93355a1497f9cf169ac1d1e
-  data.tar.gz: d81d5625a0b145b259507067c7214b3003937523965444f32631968049a3ddb686f4de6b1b711466ff76596ccbefb7dff1466d2fcf47e563e4185a170dee822d
+  metadata.gz: df344dd28a9a0bf196ced1f01d69e6382164c86f77d53d73886a9243b32177287aea7e0ed6d45a3df34aaea51823654210616947cea4a25369f92db429153cd3
+  data.tar.gz: 86b3055b01c1cbfecd431ed009375650eee9e37d2aea387cc3fad55b47c892a9b72fe1c05d4f29828d62006e640fc65c37afab35e7cab3c91d978ec39aa85961

data/.circleci/config.yml

@@ -12,7 +12,7 @@ defaults: &defaults
       DATABASE_USERNAME: pgdice
       PGDICE_LOG_TARGET: STDOUT
 
-  - image: circleci/postgres:10.4-alpine-ram
+  - image: circleci/postgres:10.6-alpine-ram
     environment:
       POSTGRES_USER: pgdice
       POSTGRES_DB: pgdice_test
@@ -42,7 +42,7 @@ jobs:
           mkdir -p /tmp/test-results
           TEST_FILES="$(circleci tests glob "test/**/*_test.rb" | circleci tests split --split-by=timings)"
 
-          bundle exec rake test
+          bundle exec rake rubocop test
           ./tmp/cc-test-reporter format-coverage -t simplecov -o tmp/coverage/codeclimate.pgdice.json tmp/coverage/pgdice/.resultset.json
 
     - store_test_results:

data/.codeclimate.yml

@@ -0,0 +1,5 @@
+version: "2"
+checks:
+  argument-count:
+    config:
+      threshold: 5

data/.rubocop.yml

@@ -3,4 +3,9 @@ Metrics/LineLength:
 
 Metrics/BlockLength:
   Exclude:
-    - pgdice.gemspec
+    - pgdice.gemspec
+
+# TODO: Evaluate if this is an acceptable parameter list. It's a constructor after all.
+Metrics/ParameterLists:
+  Exclude:
+    - lib/pgdice/table.rb

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [v0.2.0] : 2018-09-17
+### Changelog added
+
+### Added
+- Support for overriding configuration parameters. Currently only the `:logger` option is supported.
+    - [DatabaseConnection](lib/pgdice/database_connection.rb) now accepts an opts hash
+    - [PartitionHelper](lib/pgdice/partition_helper.rb) now accepts an opts hash
+    - [PartitionManager](lib/pgdice/partition_manager.rb) now accepts an opts hash
+    - [PgSliceManager](lib/pgdice/pg_slice_manager.rb) now accepts an opts hash
+    - [Validation](lib/pgdice/validation.rb) now accepts an opts hash

data/Guardfile

@@ -17,15 +17,15 @@
 #
 # and, you'll have to watch "config/Guardfile" instead of "Guardfile"
 
-guard :minitest, all_after_pass: true do
-  watch(%r{^lib/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
-  watch(%r{^test/test_helper\.rb$}) { 'test' }
-  watch(%r{^test/.+_test\.rb$})
-end
-
 guard :rubocop, cli: %w[-D -S -a] do
   watch(/.rubocop.yml/)
   watch(/.+\.rb$/)
   watch(/Rakefile/)
   watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
 end
+
+guard :minitest, all_after_pass: true do
+  watch(%r{^lib/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$}) { 'test' }
+  watch(%r{^test/.+_test\.rb$})
+end

data/README.md

@@ -2,10 +2,11 @@
 [![Coverage Status](https://coveralls.io/repos/github/IlluminusLimited/pgdice/badge.svg?branch=master)](https://coveralls.io/github/IlluminusLimited/pgdice?branch=master)
 [![Maintainability](https://api.codeclimate.com/v1/badges/311e005a14749bf2f826/maintainability)](https://codeclimate.com/github/IlluminusLimited/pgdice/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/311e005a14749bf2f826/test_coverage)](https://codeclimate.com/github/IlluminusLimited/pgdice/test_coverage)
+[![Gem Version](https://badge.fury.io/rb/pgdice.svg)](https://badge.fury.io/rb/pgdice)
 
 # PgDice
 
-PgDice is a utility that builds on top of the excellent gem
+PgDice is a utility for creating and maintaining partitioned database tables that builds on top of the excellent gem
  [https://github.com/ankane/pgslice](https://github.com/ankane/pgslice)
  
 PgDice is intended to be used by scheduled background jobs in frameworks like [Sidekiq](https://github.com/mperham/sidekiq)
@@ -17,8 +18,8 @@ where logging and clear exception messages are crucial.
 There are some features in this gem which allow you to drop database tables. 
 
 If you choose to use this software without a __tested and working__ backup and restore strategy in place then you 
-are a fool and will pay the price for your negligence. This software comes with no warranty 
-or any guarantees, implied or otherwise. By using this software you agree that the creator, 
+are a fool and will pay the price for your negligence. THIS SOFTWARE IS PROVIDED "AS IS",
+WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. By using this software you agree that the creator, 
 maintainers and any affiliated parties CANNOT BE HELD LIABLE FOR DATA LOSS OR LOSSES OF ANY KIND.
 
 See the [LICENSE](LICENSE) for more information.
@@ -51,58 +52,81 @@ This is an example config from a project using `Sidekiq`
 ```ruby
 require 'pgdice'
 PgDice.configure do |config|
-  config.logger = Sidekiq.logger # This defaults to STDOUT if you don't specify a logger
+  # This defaults to STDOUT if you don't specify a logger
+  config.logger_factory = proc { Sidekiq.logger }
   config.database_url = ENV['PGDICE_DATABASE_URL'] # postgresql://[user[:password]@][host][:port][/dbname][?param1=value1&...]
-  config.approved_tables = ENV['PGDICE_APPROVED_TABLES'] # Comma separated values: 'comments,posts'
+ 
+  # Set a config file or build the tables manually
+  config.config_file = Rails.root.join('config', 'pgdice.yml') # If you are using rails, else provide the absolute path.
+  # and/or
+  config.approved_tables = PgDice::ApprovedTables.new(
+    PgDice::Table.new(table_name: 'comments', past: 90, future: 7, period: 'day'),
+    PgDice::Table.new(table_name: 'posts', past: 6, future: 2, period: 'month')
+  )
 end
 ```
 
 
 #### Configuration Parameters
 
-`logger` Optional: The logger to use. If you don't set this it defaults to STDOUT.
-
-`database_url` The postgres database url to connect to. This is required since `pgslice` is used to accomplish some tasks
-and it only takes a `url` currently.
-
-`approved_tables` This one is important. If you want to manipulate database tables with this gem you're going to
-need to add the base table name to this string of comma-separated values.
+- `database_url` - Required: The postgres database url to connect to. 
+  - This is required since `pgslice` requires a postgres `url`.
 
-`additional_validators` Optional: This can accept an array of `proc` or `lambda` type predicates. 
-Each predicate will be passed the `params` hash and a `logger`. These predicates are called before doing things like
-dropping tables and adding tables. 
+- `logger_factory` - Optional: A factory that will return a logger to use.
+  - Defaults to `proc { Logger.new(STDOUT) }`
 
-`dry_run` Optional: You can set it to either `true` or `false`. This will make PgDice print the commands but not 
-execute them.
+- `approved_tables` - Optional: (but not really) The tables to allow modification on.
+  - If you want to manipulate database tables with this gem you're going to need to provide this data.
+    - See the [Approved Tables Configuration](#approved-tables-configuration) section for more.
 
-`older_than` Optional: Time object used to scope the queries on droppable tables. Defaults to 90 days ago.
+- `dry_run` - Optional: Boolean value to control whether changes are executed on the database.
+  - You can set it to either `true` or `false`. 
+    - `true` will make PgDice log out the commands but not execute them.
 
-`table_drop_batch_size` Optional: Maximum number of tables you can drop in one query. Defaults to 7.
+- `batch_size` - Optional: Maximum number of tables you can drop in one `drop_old_partitions` call. 
+  - Defaults to 7.
 
 
 #### Advanced Configuration Parameters
 
-`table_dropper` This defaults to [TableDropper](lib/pgdice/table_dropper.rb) which has a `lambda`-like interface. 
-An example use-case would be calling out to your backup system to confirm the table is backed up.
-This mechanism will be passed the `table_to_drop` and a `logger`.
+All of the following parameters are optional and honestly you probably will never need to mess with these.
+
+- `pg_connection` - This is a `PG::Connection` object used for the database queries made from `pgdice`.
+  - By default it will be initialized from the `database_url` if left `nil`. 
+  - Keep in mind the dependency `pgslice` will still establish its own connection using the `database_url` 
+  so this feature may not be very useful if you are trying to only use one connection for this utility.
 
-`pg_connection` This is a `PG::Connection` object used for the database queries made from `pgdice`.
- By default it will be initialized from the `database_url` if left `nil`. Keep in mind the dependency 
- `pgslice` will still establish its own connection using the `database_url` so this feature may not be very
- useful if you are trying to only use one connection for this utility.
- 
- `database_connection` You can supply your own [DatabaseConnection](lib/pgdice/database_connection.rb) if you like.
- I'm not sure why you would do this.
- 
- `pg_slice_manager` This is an internal wrapper around `pgslice`. [PgSliceManager](lib/pgdice/pg_slice_manager.rb)
-  This configuration lets you provide your own if you wish. I'm not sure why you would do this.
- 
- `partition_manager` You can supply your own [PartitionManager](lib/pgdice/partition_manager.rb) if you like.
-  I'm not sure why you would do this.
-  
- `partition_helper` You can supply your own [PartitionHelper](lib/pgdice/partition_helper.rb) if you like.
-  I'm not sure why you would do this.
  
+### Approved Tables Configuration
+
+In order to maintain the correct number of partitions over time you must configure a 
+[PgDice::Table](lib/pgdice/table.rb).
+
+An example configuration file has been provided at [config.yml](examples/config.yml) if you would rather
+declare your `approved_tables` in yaml.
+
+#### Alternative Approved Tables Configuration 
+
+If you want to declare your [PgDice::ApprovedTables](lib/pgdice/approved_tables.rb) in your configuration
+block instead, you can build them like so:
+
+```ruby
+require 'pgdice'
+PgDice.configure do |config|
+  config.approved_tables = PgDice::ApprovedTables.new(
+    PgDice::Table.new(table_name: 'comments', # Table name for the (un)partitioned table
+                      past: 90, # The minimum number of tables to keep before dropping older tables.
+                      future: 7, # Number of future tables to always have.
+                      period: 'day', # day, month, year
+                      column_name: 'created_at', # Whatever column you'd like to partition on.
+                      schema: 'public'), # Schema that this table belongs to.
+    PgDice::Table.new(table_name: 'posts') # Minimum configuration (90 past, 7 future, 'day' period).
+  )
+end
+```
+
+It is possible to use both the configuration block and a file if you so choose. 
+The block will take precedence over the values in the file.
  
 ### Converting existing tables to partitioned tables
 
@@ -119,24 +143,28 @@ For more information on what's going on in the background see
 
 
 ```ruby
-PgDice.partition_helper.partition_table!(table_name: 'comments', 
-                                            past: 30, 
-                                            future: 30, 
-                                            column_name: 'created_at', 
-                                            period: :day)
+PgDice.partition_helper.partition_table('comments')
 ```
 
 If you mess up (again you shouldn't use this in production). These two methods are useful for writing tests
 that work with partitions.
 
+#### Notes on partition_table
+
+- You can override values configured in the `PgDice::Table` by passing them in as a hash. 
+  - For example if you wanted to create `30` future tables instead of the configured `7` for the `comments` table
+  you could pass in `future: 30`.
+
 ```ruby
-PgDice.partition_helper.undo_partitioning!(table_name: 'comments')
+PgDice.partition_helper.undo_partitioning!('comments')
 ```
 
-In `partition_helper` there are versions of the methods that will throw exceptions (ending in `!`) and others 
+#### Notes on `partition_table`
+
+- In `partition_helper` there are versions of the methods that will throw exceptions (ending in `!`) and others 
 that will return a truthy value or `false` if there is a failure.
 
-`period` can be set to one of these values: `:day`, `:month`, `:year`
+- `period` can be set to one of these values: `:day`, `:month`, `:year`
 
 
 ### Maintaining partitioned tables
@@ -146,30 +174,28 @@ that will return a truthy value or `false` if there is a failure.
 If you have existing tables that need to periodically have more tables added you can run:
 
 ```ruby
-PgDice.partition_manager.add_new_partitions(table_name: 'comments', future: 30)
+PgDice.partition_manager.add_new_partitions('comments')
 ```
 
-The above command would add 30 new tables and their associated indexes all based on the `period` that the
+##### Notes on `add_new_partitions`
+
+- The above command would add `7` new tables and their associated indexes all based on the `period` that the
 partitioned table was defined with.
+ - The example `comments` table we have been using was configured to always keep `7` future partitions above.
 
 
-#### Listing old tables
+#### Listing droppable partitions
 
 Sometimes you just want to know what's out there and if there are tables ready to be dropped.
 
 To list all eligible tables for dropping you can run:
 ```ruby
-PgDice.partition_manager.list_old_partitions(table_name: 'comments', older_than: Time.now.utc - 90*24*60*60)
+PgDice.partition_manager.list_droppable_partitions('comments')
 ```
 
-If you have `active_support` you could do:
-```ruby
-PgDice.partition_manager.list_old_partitions(table_name: 'comments', older_than: 90.days.ago)
-```
+##### Notes on `list_droppable_partitions`
 
-Technically `older_than` is optional and defaults to `90 days` (see the configuration section).
-It is recommended that you pass it in to be explicit, but you can rely on the configuration 
-mechanism if you so choose.
+- This method uses the `past` value from the `PgDice::Table` to determine which tables are eligible for dropping.
 
 
 #### Dropping old tables
@@ -179,24 +205,16 @@ _Dropping tables is irreversible! Do this at your own risk!!_
 If you want to drop old tables (after backing them up of course) you can run:
 
 ```ruby
-PgDice.partition_manager.drop_old_partitions(table_name: 'comments', older_than: Time.now.utc - 90*24*60*60)
-```
-
-If you have `active_support` you could do:
-```ruby
-PgDice.partition_manager.drop_old_partitions(table_name: 'comments', older_than: 90.days.ago)
+PgDice.partition_manager.drop_old_partitions(table_name: 'comments')
 ```
 
-This command would drop old partitions that are older than `90` days.
-
-Technically `older_than` is optional and defaults to `90 days` (see the configuration section).
-It is recommended that you pass it in to be explicit, but you can rely on the configuration 
-mechanism if you so choose.
-
-Another good reason to pass in the `older_than` parameter is if you are managing tables that
-are partiioned by different schemes or have different use-cases 
-e.g. daily vs yearly partitioned tables.
+##### Notes on `drop_old_partitions`
 
+- The above example command would drop partitions that exceed the configured `past` table count
+for the `PgDice::Table`. 
+  - The example `comments` table has been configured with `past: 90` tables. 
+  So if there were 100 tables older than `today` it would drop up to `batch_size` tables.
+  
 
 #### Validating everything is still working
 
@@ -205,7 +223,7 @@ ensure they are actually working correctly.
 
 To validate that your expected number of tables exist, you can run:
 ```ruby
-PgDice.validation.assert_tables(table_name: 'comments', future: 30, past: 90)
+PgDice.validation.assert_tables('comments', future: 7, past: 90)
 ```
 
 An [InsufficientTablesError](lib/pgdice.rb) will be raised if any conditions are not met.
@@ -215,6 +233,25 @@ still a table from 90 days ago. The above example assumes the table was partitio
 by day.
 
 
+## FAQ
+
+1. How do I get a postgres url if I'm running in Rails?
+```ruby
+ def build_postgres_url
+  config = Rails.configuration.database_configuration
+  host = config[Rails.env]["host"]
+  database = config[Rails.env]["database"]
+  username = config[Rails.env]["username"]
+  password = config[Rails.env]["password"]
+
+  "postgres://#{username}:#{password}@#{host}/#{database}"
+end
+```
+
+1. I'm seeing off-by-one errors for my `validation.assert_tables` calls?
+    - You should make sure your database is configured to use `UTC`.
+    [https://www.postgresql.org/docs/10/datatype-datetime.html](https://www.postgresql.org/docs/10/datatype-datetime.html) 
+
 ## Planned Features
 
 1. Full `PG::Connection` support (no more database URLs).
@@ -227,9 +264,7 @@ by day.
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 
 ### Running tests

data/Rakefile

@@ -2,6 +2,9 @@
 
 require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'

data/examples/config.yml

@@ -0,0 +1,13 @@
+approved_tables:
+- table_name: comments # Table name for the (un)partitioned table
+  past: 1 # The minimum number of tables to keep before dropping older tables.
+  future: 0 # Number of future tables to always have. I like to set this to 7x the period just to be safe.
+  column_name: created_at # Whatever column you'd like to partition on.
+  period: day # day, month, year
+  schema: public
+- table_name: posts
+  past: 10
+  future: 0
+  column_name: created_at
+  period: day
+  schema: public

data/lib/pgdice/approved_tables.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module PgDice
+  # Hash-like object to contain approved tables. Adds some convenience validation and a simpleish interface.
+  class ApprovedTables
+    attr_reader :tables
+    extend Forwardable
+
+    def_delegators :@tables, :size, :empty?
+
+    def initialize(*args)
+      @tables = args.flatten.compact
+
+      raise ArgumentError, 'Objects must be a PgDice::Table!' unless tables.all? { |item| item.is_a?(PgDice::Table) }
+    end
+
+    def [](arg)
+      key = check_string_args(arg)
+      tables.select { |table| table.name == key }.first
+    end
+
+    def include?(arg)
+      key = check_string_args(arg)
+      return true if self.[](key)
+
+      false
+    end
+
+    def fetch(arg)
+      key = check_string_args(arg)
+      found_table = self.[](key)
+      raise PgDice::IllegalTableError, "Table name: '#{key}' is not in the list of approved tables!" unless found_table
+
+      found_table
+    end
+
+    def <<(object)
+      raise ArgumentError, 'Objects must be a PgDice::Table!' unless object.is_a?(PgDice::Table)
+
+      object.validate!
+      return self if include?(object.name)
+
+      @tables << object
+      self
+    end
+
+    def smash(table_name, override_parameters)
+      fetch(table_name).smash(override_parameters)
+    end
+
+    def ==(other)
+      tables.sort == other.tables.sort
+    end
+
+    private
+
+    def check_string_args(key)
+      raise ArgumentError, 'key must be a String' unless key.is_a?(String)
+
+      key
+    end
+  end
+end

data/lib/pgdice/configuration.rb

@@ -5,52 +5,52 @@ module PgDice
   class << self
     attr_accessor :configuration
 
-    def configure
+    def configure(validate_configuration: true)
       self.configuration ||= PgDice::Configuration.new
       yield(configuration)
+      configuration.validate! if validate_configuration
     end
   end
 
   # Configuration class which holds all configurable values
   class Configuration
-    def self.days_ago(days)
-      Time.now.utc - days * 24 * 60 * 60
-    end
-
-    VALUES = { logger: Logger.new(STDOUT),
-               database_url: nil,
-               additional_validators: [],
-               approved_tables: [],
-               older_than: PgDice::Configuration.days_ago(90),
-               dry_run: false,
-               table_drop_batch_size: 7 }.freeze
+    DEFAULT_VALUES ||= { logger_factory: proc { Logger.new(STDOUT) },
+                         database_url: nil,
+                         dry_run: false,
+                         batch_size: 7 }.freeze
 
     attr_writer :logger,
+                :logger_factory,
                 :database_url,
-                :additional_validators,
                 :approved_tables,
-                :older_than,
                 :dry_run,
-                :table_drop_batch_size,
-                :database_connection,
-                :pg_connection
-
-    attr_accessor :table_dropper,
-                  :pg_slice_manager,
-                  :partition_manager,
-                  :partition_helper
-
-    def initialize(existing_configuration = nil)
-      VALUES.each do |key, value|
-        initialize_value(key, value, existing_configuration)
+                :batch_size,
+                :pg_connection,
+                :config_file_loader
+
+    attr_accessor :config_file
+
+    def initialize(existing_config = nil)
+      DEFAULT_VALUES.each do |key, value|
+        initialize_value(key, value, existing_config)
       end
+      @approved_tables = PgDice::ApprovedTables.new(existing_config&.approved_tables(eager_load: true)&.tables)
       initialize_objects
     end
 
-    def logger
-      return @logger unless @logger.nil?
+    def validate!
+      logger_factory
+      database_url
+      database_connection
+      pg_connection
+      batch_size
+      approved_tables
+    end
 
-      raise PgDice::InvalidConfigurationError, 'logger must be present!'
+    def logger_factory
+      return @logger_factory if @logger_factory.respond_to?(:call)
+
+      raise PgDice::InvalidConfigurationError, 'logger_factory must be present!'
     end
 
     def database_url
@@ -59,28 +59,32 @@ module PgDice
       raise PgDice::InvalidConfigurationError, 'database_url must be present!'
     end
 
-    def database_connection
-      return @database_connection unless @database_connection.nil?
-
-      raise PgDice::InvalidConfigurationError, 'database_connection must be present!'
-    end
+    def approved_tables(eager_load: false)
+      return @approved_tables if eager_load
+      unless @approved_tables.respond_to?(:empty?)
+        raise PgDice::InvalidConfigurationError, 'approved_tables must be an instance of PgDice::ApprovedTables!'
+      end
 
-    def additional_validators
-      return @additional_validators if @additional_validators.is_a?(Array)
+      if !config_file_loader.file_loaded? && config_file.present?
+        config_file_loader.load_file
+        @approved_tables
+      end
 
-      raise PgDice::InvalidConfigurationError, 'additional_validators must be an Array!'
+      @approved_tables
     end
 
-    def approved_tables
-      return @approved_tables if @approved_tables.is_a?(Array)
+    # Lazily initialized
+    def pg_connection
+      @pg_connection ||= PG::Connection.new(database_url)
+      return @pg_connection if @pg_connection.respond_to?(:exec)
 
-      raise PgDice::InvalidConfigurationError, 'approved_tables must be an Array of strings!'
+      raise PgDice::InvalidConfigurationError, 'pg_connection must be present!'
     end
 
-    def older_than
-      return @older_than if @older_than.is_a?(Time)
+    def batch_size
+      return @batch_size.to_i if @batch_size.to_i >= 0
 
-      raise PgDice::InvalidConfigurationError, 'older_than must be a Time!'
+      raise PgDice::InvalidConfigurationError, 'batch_size must be a non-negative Integer!'
     end
 
     def dry_run
@@ -89,18 +93,28 @@ module PgDice
       raise PgDice::InvalidConfigurationError, 'dry_run must be either true or false!'
     end
 
-    def table_drop_batch_size
-      return @table_drop_batch_size.to_i if @table_drop_batch_size.to_i >= 0
+    def config_file_loader
+      @config_file_loader ||= ConfigurationFileLoader.new(self)
+    end
 
-      raise PgDice::InvalidConfigurationError, 'table_drop_batch_size must be a non-negative Integer!'
+    def logger
+      @logger ||= logger_factory.call
     end
 
-    # Lazily initialized
-    def pg_connection
-      @pg_connection ||= PG::Connection.new(database_url)
-      return @pg_connection if @pg_connection.respond_to?(:exec)
+    def partition_manager
+      @partition_manager_factory.call
+    end
 
-      raise PgDice::InvalidConfigurationError, 'pg_connection must be present!'
+    def partition_helper
+      @partition_helper_factory.call
+    end
+
+    def validation
+      @validation_factory.call
+    end
+
+    def database_connection
+      @database_connection_factory.call
     end
 
     def deep_clone
@@ -114,9 +128,10 @@ module PgDice
     end
 
     def initialize_objects
-      @database_connection = PgDice::DatabaseConnection.new(self)
-      @partition_manager = PgDice::PartitionManager.new(self)
-      @table_dropper = PgDice::TableDropper.new(self)
+      @partition_manager_factory = PgDice::PartitionManagerFactory.new(self)
+      @partition_helper_factory = PgDice::PartitionHelperFactory.new(self)
+      @validation_factory = PgDice::ValidationFactory.new(self)
+      @database_connection_factory = PgDice::DatabaseConnectionFactory.new(self)
     end
   end
 end