database_transform 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a266c8fa585850029bbf5f9dc845433db966782
-  data.tar.gz: ee2da09e5e7e473209377e3003363696e5cc113f
+  metadata.gz: 5260295aa827b58fa3504b901e310810dfb36a4a
+  data.tar.gz: f15c12e08f7b6b736af4dc86e1d97ae0b33cd394
 SHA512:
-  metadata.gz: e33caabcd8f7c37f70e98403a9824a6a80e7f6ff3177d167a9366bbc4c412fbb468486e373499852a38cc3d39e64b2322fe24034a0219b5a045d98a66006b26a
-  data.tar.gz: 7f1b7b15d9576c2a707a77e2857d075abd99e48d2b5ea11f42af000a7a60fb05627aa0ceb441fd5f9d18e3d117deaa781948452677318021bf17feb0359dd186
+  metadata.gz: 8c1d1982ff7532f8a7d21ab1c5541aa1169830bdcf07acecf14e8f5976d0a5d40ad498e4d48d17a3f0c32781a0657802ca1f937ce1c0cf79aeb6b737d657a069
+  data.tar.gz: 51a77ad4b478b66270af5f4e974da544a431886d49b146f154e485e1564314d37cf3c65e7dcfbb13155eb64f4a420cbfbe00f20fcf135f5f8568cf7d3aa098b0

data/.rspec

@@ -1,2 +1,2 @@
---format documentation
 --color
+--require spec_helper

data/README.md

@@ -1,8 +1,18 @@
-# DatabaseTransform
+# Database Transform
+[![Build Status](https://travis-ci.org/lowjoel/database_transform.svg)](https://travis-ci.org/lowjoel/database_transform)
+[![Coverage Status](https://coveralls.io/repos/lowjoel/database_transform/badge.svg)](https://coveralls.io/r/lowjoel/database_transform)
+[![Code Climate](https://codeclimate.com/github/lowjoel/database_transform/badges/gpa.svg)](https://codeclimate.com/github/lowjoel/database_transform)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/database_transform`. To experiment with that code, run `bin/console` for an interactive prompt.
+This gem will allow you to transform a database's contents across schemas with a simple DSL. This is useful when
+migrating from an application written in another framework to Rails, allowing programmers to reason about how an old
+schema maps to a new one.
 
-TODO: Delete this and the text above, and describe your gem
+Similar gems exist:
+
+ - [legacy_migrations](https://github.com/btelles/legacy_migrations)
+ - [super_migration](https://github.com/christian/super_migration)
+
+However, they have not been updated for a few years.
 
 ## Installation
 
@@ -22,13 +32,80 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Database Transform is built with ActiveRecord in mind. First, define a new database conndtion to the old database in
+database.yml:
+
+```yaml
+my_old_app_production:
+  adapter: postgresql
+  host: old_server
+  database: my_old_app
+```
 
-## Development
+Then, define the define a transform in `db/transforms/my_old_app_schema.rb`:
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+class MyOldAppSchema < DatabaseTransform::Schema
+  transform_table :users, to: ::User, scope: proc { where('uid <> 0') } do
+    primary_key :uid
+    column :mail, to: :email
+    column :pass, to: :password do |password|
+      self.password_confirmation = password
+    end
+  end
+  
+  transform_table :posts, to: ::Post do
+    primary_key :post_id
+    column :uid, to: :user, null: false do |uid|
+      Source::User.transform(uid)
+    end
+    column :content
+    save unless: proc { content.empty? }
+  end
+end
+```
 
-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` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+A summary of methods:
+
+ - `transform_table` tells Database Transform to perform the given transform over records in the given source table.
+   - The first argument is the table to transform. This can be a symbol, string, or an ActiveRecord model.
+   - `to` specifies the new table to transform to. This can be a symbol, string, or an ActiveRecord model.
+     - If either argument is a symbol or string, an ActiveRecord model is generated which allows access to the record's
+       data.
+       - Source models are found in the Source namespace, and can be used as the `posts.uid` column above.
+       - Destination models are found in the Destination namespace.
+     - In all cases, the model will have extra accessory methods:
+       - `transform(old_primary_key)`: This takes a primary key in the source table, and returns the transformed object.
+         This only returns a valid result after the object has been transformed.
+       - `transformed?(old_primary_key)`: This checks if the object has been transformed.
+   - `default_scope` allows the programmer to specify the records to transform
+ - `primary_key` declares the name of column with the primary key. This allows later access when relations need to be
+    mapped.
+ - `column` declares how to transform the contents of that column from the old database to the new one.
+   - If `to:` is omitted, then it is assumed that the transfer function is the identity function, and the column would
+     map across as the same name.
+   - If `null: false` is specified, the value assigned to the column (in `to`) will be checked for nullity.
+   - A block can be provided.
+     - If so, then the data from the old record is passed to the block as the first argument
+     - In the context of the block, `self` refers to the new record.
+     - `self` has an additional attribute `source_record` which refers to the old record. (TODO)
+     - `self` has an additional attribute `schema` which refers to the transformation schema. (TODO)
+ - `save` declares whether the new record should be saved.
+   - `if` and `unless` accepts a block which will be evaluated to determine if the record should be saved.
+   - `validate` will allow the record to be saved bypassing validations. This defaults to `true`.
+
+Finally, execute the Rake task:
+
+    $ rake db:transform my_old_app
+
+And the schema (`MyOldAppSchema`) and database connection (via `my_old_app_production`) will be established for you. A
+few variants of the schema name will be checked:
+
+ - my_old_app
+ - my_old_app_production
+
+Only the *source* schema will be annotated to use the other connection. The *destination* schema will be used through
+the application's normal configuration (i.e. depends on the value of `ENV['RAILS_ENV']`.)
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,13 @@
 require "bundler/gem_tasks"
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/database_transform.gemspec

@@ -19,6 +19,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activerecord'
+
   spec.add_development_dependency 'bundler', '~> 1.9'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'codeclimate-test-reporter'
 end

data/lib/database_transform.rb

@@ -1,5 +1,17 @@
-require "database_transform/version"
+require 'database_transform/version'
 
 module DatabaseTransform
-  # Your code goes here...
+  extend ActiveSupport::Autoload
+
+  autoload :DuplicateError
+  autoload :UnsatisfiedDependencyError
+
+  autoload :SchemaTables
+  autoload :SchemaModelStore
+  autoload :Schema
+
+  autoload :SchemaTableRecordMapping
+  autoload :SchemaTable
+
+  require 'database_transform/railtie' if defined?(Rails)
 end

data/lib/database_transform/duplicate_error.rb

@@ -0,0 +1,10 @@
+class DatabaseTransform::DuplicateError < StandardError
+  def initialize(column)
+    super
+    @column = column
+  end
+
+  def to_s
+    "The column #{@column} had multiple transforms."
+  end
+end

data/lib/database_transform/railtie.rb

@@ -0,0 +1,5 @@
+class DatabaseTransform::Railtie < Rails::Railtie
+  rake_tasks do
+    load 'database_transform/tasks/transform.rake'
+  end
+end

data/lib/database_transform/schema.rb

@@ -0,0 +1,123 @@
+class DatabaseTransform::Schema
+  extend DatabaseTransform::SchemaModelStore
+  extend DatabaseTransform::SchemaTables
+
+  # Transforms a table from the source database to the new database.
+  #
+  # Specify the source table to get entries from; a proc with the transform steps can be specified.
+  #
+  # @option args [String, Symbol, Class] to The name of the destination table; if this is not specified, no tables are
+  #    copied. This can be a class, or a symbol which will be constantised; each column mapping proc will have access to
+  #    one instance of this table when performing a transformation.
+  # @option args [Array<String, Symbol>] depends An array of symbols (source tables) which must be transformed before
+  #    the specified source table can be transformed.
+  # @option args [Proc] default_scope The default scope of the old table to use when transforming.
+  def self.transform_table(source_table, args = {}, &proc)
+    raise ArgumentError.new if source_table.nil?
+    raise DatabaseTransform::DuplicateError.new(source_table) if tables.has_key?(source_table)
+
+    source_table, args[:to] = prepare_models(source_table, args[:to])
+
+    transform = DatabaseTransform::SchemaTable.new(source_table, args[:to], args[:default_scope])
+    tables[source_table] = { depends: args[:depends] || [], transform: transform }
+    transform.instance_eval(&proc) if proc
+  end
+
+  class << self
+    private
+
+    def prepare_models(source_table, destination_table)
+      source_table = generate_model(const_get(:Source), source_table) unless source_table.is_a?(Class)
+      set_connection_for_model(source_table, deduce_connection_name)
+
+      if !destination_table.nil? && !destination_table.is_a?(Class)
+        destination_table = generate_model(const_get(:Destination), destination_table)
+      end
+
+      [source_table, destination_table]
+    end
+
+    def generate_model(within, table_name)
+      class_name = ActiveSupport::Inflector.camelize(ActiveSupport::Inflector.singularize(table_name.to_s))
+      within.module_eval <<-EndCode, __FILE__, __LINE__ + 1
+        class #{class_name} < ActiveRecord::Base
+          self.table_name = '#{table_name.to_s}'
+        end
+        #{class_name.to_s.singularize.camelize}
+      EndCode
+    end
+
+    # Deduces the connection name from the name of the schema class.
+    #
+    # @return [String] The name of the connection to use.
+    def deduce_connection_name
+      deduced_connection_name = ActiveSupport::Inflector.underscore(name)
+      return deduced_connection_name if connection_name_exists?(deduced_connection_name)
+
+      deduced_connection_name << '_production'
+    end
+
+    # Checks if the given connection name exists
+    #
+    # @param [String] name The name of the connection to check.
+    # @return [Boolean] True if the connection exists.
+    def connection_name_exists?(name)
+      ActiveRecord::Base.configurations.has_key?(name)
+    end
+
+    # Sets the connection for the given model, using the given connection name.
+    #
+    # @param [Class] model The model to set the connection on.
+    # @param [String] connection_name The name of the connection to set.
+    # @return [Void]
+    def set_connection_for_model(model, connection_name)
+      model.establish_connection(connection_name.to_sym)
+    end
+  end
+
+  # Runs the transform.
+  #
+  # @raise [DatabaseTransform::UnsatisfiedDependencyError] When the dependencies for a table cannot be satisfied, and no
+  #   progress can be made.
+  # @return [Void]
+  def transform!
+    # The tables have dependencies; we must run them in order.
+    transformed = Set.new
+    queue = Set.new(tables.keys)
+
+    # We try to run all the transforms we can until no more can be run.
+    # If no more can run and the input queue is empty, we are done.
+    # If no more can run and the input queue is not empty, we have a dependency cycle.
+    begin
+      transformed_this_pass = transform_pass(transformed, queue)
+      fail DatabaseTransform::UnsatisfiedDependencyError.new(queue.to_a) if transformed_this_pass.empty? && !queue.empty?
+
+      queue -= transformed_this_pass
+      transformed += transformed_this_pass
+    end until queue.empty?
+  end
+
+  private
+
+  # Performs a transform over all elements of the queue who has its dependencies satisfied.
+  #
+  # @param [Array<Symbol>] transformed The models which have been transformed.
+  # @param [Array<Symbol>] queue The models which need to be transformed.
+  # @return [Set<Symbol>] The set of models which were transformed this pass.
+  def transform_pass(transformed, queue)
+    transformed_this_pass = Set.new
+    queue.each do |table|
+      # Check that all dependencies are satisfied
+      table_config = tables[table]
+      unmet_dependencies = table_config[:depends].select do |s|
+        !transformed.include?(s) && !transformed_this_pass.include?(s)
+      end
+      next unless unmet_dependencies.empty?
+
+      table_config[:transform].run_transform
+      transformed_this_pass << table
+    end
+
+    transformed_this_pass
+  end
+end

data/lib/database_transform/schema_model_store.rb

@@ -0,0 +1,7 @@
+# Implements a model namespace for database tables without an explicit model.
+module DatabaseTransform::SchemaModelStore
+  def inherited(class_)
+    class_.const_set(:Source, Module.new)
+    class_.const_set(:Destination, Module.new)
+  end
+end

data/lib/database_transform/schema_table.rb

@@ -0,0 +1,224 @@
+# Represents a transformation from a source table to a destination table.
+class DatabaseTransform::SchemaTable
+  # Initialises the table definition for a particular schema
+  #
+  # @param [Class] source The model class to map source records from
+  # @param [Class] destination The model class to map destination records to
+  # @param [nil, Proc] default_scope The default scope for querying the source table.
+  def initialize(source, destination, default_scope)
+    @source = source
+    @source.extend(DatabaseTransform::SchemaTableRecordMapping)
+    @destination = destination
+    @destination.extend(DatabaseTransform::SchemaTableRecordMapping) if @destination
+    @default_scope = default_scope
+
+    @primary_key = nil
+    @save = nil
+    @columns = []
+  end
+
+  # Declare the primary key of the source table.
+  #
+  # @param [Symbol] id The name of the column in the source table which is the primary key.
+  def primary_key(id)
+    raise DatabaseTransform::DuplicateError.new(id) if @primary_key
+    @primary_key = id
+    @source.primary_key = id
+  end
+
+  # Declare the mapping for the source table to the new table.
+  #
+  # This function takes source columns to provide to the mapping proc as arguments.
+  #
+  # The destination column is specified as the to hash parameter.
+  # If no mapping block is specified, the source column is copied to the destination column without modification. This
+  # is not possible if more than one source column is specified.
+  # If the mapping block is specified, if the destination column is specified, the result of the block is used as the
+  # destination column's value.
+  # Otherwise, the result is unused. This can be used to execute the block purely for side-effects
+  #
+  # @option options [Symbol] to The column to map to.
+  # @option options [Boolean] null If to is specified, this can be false which enforces that nil is never added to the
+  #   database.
+  def column(*args, &block)
+    raise ArgumentError if args.length < 1
+
+    # Get the columns
+    options = args.extract_options!
+    source_columns = args
+    to_column = options.delete(:to)
+    to_column ||= source_columns.first unless block
+
+    validate_column_options!(source_columns, to_column, options, block)
+
+    # Store the mapping
+    @columns << {
+        from: source_columns,
+        to: to_column,
+        null: options[:null].nil? ? true : options[:null],
+        block: block
+    }
+  end
+
+  # Specifies a save clause.
+  #
+  # @option options [Proc] unless The record will be saved if the proc returns a false value. This cannot be used
+  #   together with if.
+  # @option options [Proc] if A proc to call. The record will be saved if the proc returns a true value. This cannot be
+  #   used together with unless.
+  def save(options = {})
+    raise ArgumentError.new('unless and if cannot be both specified') if options[:unless] && options[:if]
+    raise ArgumentError.new('Cannot specify a save clause twice for the same table') if @save
+
+    if options[:unless]
+      clause = options.delete(:unless)
+      options[:if] = ->(*callback_args) { !self.instance_exec(*callback_args, &clause) }
+    end
+
+    @save = options
+  end
+
+  # @api private
+  #   To be called only by Schema#run_transform
+  def run_transform
+    before_message =
+      if @destination
+        format("-- transforming '%s' to '%s'\n", @source.table_name, @destination.table_name)
+      else
+        format("-- transforming '%s'\n", @source.table_name)
+      end
+
+    time_block(before_message, "   -> %fs\n", &method(:transform!))
+  end
+
+  private
+
+  # Validates the options given to the #column method.
+  def validate_column_options!(source_columns, to_column, options, block)
+    raise ArgumentError.new unless to_column.nil? || to_column.is_a?(Symbol)
+    raise ArgumentError.new if !block && source_columns.length > 1
+    raise ArgumentError.new if options[:null] == false && !to_column
+  end
+
+  # Performs the given operation, timing it and printing before and after messages for executing the block.
+  #
+  # @param [String] before The message to print before the operation.
+  # @param [String] after The message to print after the operation. One floating point format argument is available,
+  #   which is the time taken for the operation.
+  # @return The result of executing the block.
+  # @yield The block to time.
+  def time_block(before, after, &proc)
+    start = Time.now
+    $stderr.puts(before)
+
+    result = proc.call
+
+    complete = Time.now - start
+    $stderr.printf(after, complete)
+
+    result
+  end
+
+  # Performs the transform with the given parameters.
+  #
+  # @return [Void]
+  def transform!
+    # For each item in the old model
+    default_scope = @default_scope || @source.method(:all)
+    @source.instance_exec(&default_scope).each do |record|
+      transform_record!(record)
+    end
+  end
+
+  # Transforms one record from the source model to the destination.
+  #
+  # @param [ActiveRecord::Base] old The record to map.
+  # @return [Void]
+  def transform_record!(old)
+    # Instantiate a new model record
+    new = @destination.new if @destination
+
+    # Map the columns over
+    transform_record_columns!(old, new)
+    return if new.nil? || new.frozen?
+
+    save_transformed_record(old, new)
+  end
+
+  # Applies the column transforms over the old record to the new record.
+  #
+  # @param [ActiveRecord::Base] old The record to map.
+  # @param [ActiveRecord::Base] new The record to map to.
+  # @return [Void]
+  def transform_record_columns!(old, new)
+    @columns.each do |column|
+      fail ArgumentError.new unless column.is_a?(Hash)
+
+      new_value = transform_record_field!(old, new, column[:from], column[:block])
+
+      unless new.nil?
+        break if new.frozen?
+        next if column[:to].nil?
+
+        assign_record_field!(old, new, column, new_value)
+      end
+    end
+  end
+
+  # Transforms one record's field.
+  #
+  # @param [ActiveRecord::Base] source The source row to map the values for.
+  # @param [ActiveRecord::Base] destination The destination row to map the values to.
+  # @param [Array<Symbol>] from The source columns to be used to map to the destination column.
+  # @param [Proc, nil] block The block to transform the source values to the destination value.
+  # @return The result of applying the transform over the input values.
+  def transform_record_field!(source, destination, from = nil, block = nil)
+    # Get the old record column values (can be a block taking multiple arguments)
+    new_values = from.map { |k| source.send(k) }
+
+    if block.nil?
+      # We have to ensure the value is a scalar
+      new_values.first
+    elsif destination
+      # Map the value if necessary.
+      # TODO: Provide the schema instance to the callback.
+      #       We should ensure that the block has a way to access the schema.
+      destination.instance_exec(*new_values, &block)
+    else
+      # Call the proc
+      block.call(*new_values)
+    end
+  end
+
+  # Assigns the transformed value to the new record, raising an argument error if the field was declared to not be
+  # nullable and the value is null.
+  #
+  # @param [ActiveRecord::Base] old The source row to map the values for.
+  # @param [ActiveRecord::Base] new The destination row to map the values to.
+  # @param [Hash] column The column mapping definition being used.
+  # @param new_value The new value to assign to the field.
+  # @return [Void]
+  def assign_record_field!(old, new, column, new_value)
+    if new_value.nil? && column[:null] == false
+      old_value = @primary_key ? old.send(@primary_key) : old.inspect
+      raise ArgumentError.new("Key #{column[:from]} for row #{old_value} in #{@source.table_name} maps to null for "\
+            'non-nullable column')
+    end
+
+    new.send("#{column[:to]}=", new_value)
+  end
+
+  # Saves the newly transformed record, and then memoizes the transformed value.
+  #
+  # @param [ActiveRecord::Base] old The source row to map the values for.
+  # @param [ActiveRecord::Base] new The destination row to map the values to.
+  # @return [Void]
+  def save_transformed_record(old, new)
+    # Save. Skip if the conditional callback is given
+    return if @save && @save[:if] && !new.instance_exec(&@save[:if])
+
+    # TODO: Make validation optional using the save clause.
+    new.save!(validate: false) unless new.destroyed?
+    @source.memoize_transform(old.send(@primary_key), new) if @primary_key
+  end
+end

data/lib/database_transform/schema_table_record_mapping.rb

@@ -0,0 +1,31 @@
+module DatabaseTransform::SchemaTableRecordMapping
+  # Obtains the result of transforming the record with the given primary key.
+  #
+  # @param old_primary_key The primary key of the record to obtain the result for.
+  # @raise [ActiveRecord::RecordNotFound] When the primary has not been transformed, or the primary key does not exist.
+  # @return The new record after transformation.
+  def transform(old_primary_key)
+    @transformed ||= {}
+    unless @transformed.has_key?(old_primary_key)
+      raise ActiveRecord::RecordNotFound.new("Key #{old_primary_key} in #{table_name}")
+    end
+
+    @transformed[old_primary_key]
+  end
+
+  # Checks if the given primary key has been transformed.
+  #
+  # @param old_primary_key The primary key of the record to obtain the result for.
+  # @return [Boolean] True if the record has been transformed.
+  def transformed?(old_primary_key)
+    @transformed ||= {}
+    @transformed.has_key?(old_primary_key)
+  end
+
+  # @api private
+  #   Called by TableTransform#run_transform
+  def memoize_transform(old_primary_key, result)
+    @transformed ||= {}
+    @transformed[old_primary_key] = result
+  end
+end

data/lib/database_transform/schema_tables.rb

@@ -0,0 +1,13 @@
+module DatabaseTransform::SchemaTables
+  def self.extended(class_)
+    class_.class_attribute :tables
+    class_.tables = {}.freeze
+  end
+
+  def inherited(class_)
+    def class_.tables
+      @tables ||= ancestors[1].tables.dup
+    end
+    super
+  end
+end

data/lib/database_transform/tasks/transform.rake

@@ -0,0 +1,35 @@
+# This class just loads the file containing the schema definition and hands off control to the schema.
+class DatabaseTransform::Transform
+  def initialize(args)
+    @schema = args.schema_name
+    @extra_args = args.extras
+    run
+  end
+
+  def run
+    import_schema
+    schema = @schema.constantize.new
+
+    ActiveRecord::Base.logger = Logger.new('log/import.log')
+    schema.transform!
+  end
+
+  private
+
+  def import_schema
+    schema_file = @schema.underscore
+    begin
+      return require(File.join(Rails.root, 'db', 'transforms', schema_file))
+    rescue LoadError
+    end
+
+    require (File.join(Rails.root, 'db', 'transforms', schema_file, schema_file))
+  end
+end
+
+namespace :db do
+  desc 'Transform old database schemas'
+  task :transform, [:schema_name] => :environment do |_, args|
+    DatabaseTransform::Transform.new(args)
+  end
+end

data/lib/database_transform/unsatisfied_dependency_error.rb

@@ -0,0 +1,6 @@
+class DatabaseTransform::UnsatisfiedDependencyError < StandardError
+  def initialize(tables)
+    @tables = tables
+    super(tables.join(', '))
+  end
+end

data/lib/database_transform/version.rb

@@ -1,3 +1,3 @@
 module DatabaseTransform
-  VERSION = "0.1.0"
+  VERSION = '0.1.1'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: database_transform
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Joel Low
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-27 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,12 +66,67 @@ dependencies:
     - - "~>"
       - !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: codeclimate-test-reporter
+  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'
 description: Transforms the data of a database from an old schema to a new one.
 email:
 - joel@joelsplace.sg
 executables:
 - console
-- setup
 extensions: []
 extra_rdoc_files: []
 files:
@@ -55,9 +138,17 @@ files:
 - README.md
 - Rakefile
 - bin/console
-- bin/setup
 - database_transform.gemspec
 - lib/database_transform.rb
+- lib/database_transform/duplicate_error.rb
+- lib/database_transform/railtie.rb
+- lib/database_transform/schema.rb
+- lib/database_transform/schema_model_store.rb
+- lib/database_transform/schema_table.rb
+- lib/database_transform/schema_table_record_mapping.rb
+- lib/database_transform/schema_tables.rb
+- lib/database_transform/tasks/transform.rake
+- lib/database_transform/unsatisfied_dependency_error.rb
 - lib/database_transform/version.rb
 homepage: https://github.com/lowjoel/database_transform
 licenses:

data/bin/setup

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