mysql2postgres 0.3.3 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44c431dce8b1d09c5ebef95e6f1a56dbc2d7b79e67b594821d9a33c287d5d2b5
-  data.tar.gz: cf5352e91abcd255f2286a95a5a0c3c1dadae5cd3804f0914ea8dee999e27f4d
+  metadata.gz: 1108264fc3155986e78c07a12abd11c6ef39a1fb671a252e6921bf4bbf7f3a4b
+  data.tar.gz: 19837bf3a64bf6a204c9325b1271566e982467f7a3e9a53f966681c8a680e1ad
 SHA512:
-  metadata.gz: 34cce30cf4cffd22bc21e0be57267da80f5806ebeebfcd2934acb6f306af79ba5da512065a8acd5367964a5af00265cea9b3c5cfbacc1f6e7425412300613420
-  data.tar.gz: 72c40e74f83546cac80b33e8b22ecb7f8035ec15ace7a572d95373c83ce4055fde7809f52f7a0608fb7a426197d4c6a71cb39f815f3719f1a52adaf1ade266a2
+  metadata.gz: e5c54b071adaa63e1bfa5819fcadc7520f1063a4a0d2218adb5337361df259ddf574ab37bec2bc7f7683a0c4024679fd87c6d6715fe692a56768365cb5021a71
+  data.tar.gz: 992c22cdfa9e8ebea90fdecb10f95a00367b3ba9cd744c6cb0d954a0a2be81138376319a7f657337e8a50b83cd4969e577e7b6de480369e34edd1b9dcc8697e6

data/.gitignore

@@ -7,3 +7,5 @@ config/database.yml
 Gemfile.lock
 pkg
 test/fixtures/test*.sql
+.enable_dev
+.enable_test

data/README.md

@@ -2,8 +2,7 @@
 
 [![Run Linters](https://github.com/AlphaNodes/mysql2postgres/workflows/Run%20Rubocop/badge.svg)](https://github.com/AlphaNodes/mysql2postgres/actions/workflows/rubocop.yml) [![Run Tests](https://github.com/AlphaNodes/mysql2postgres/workflows/Tests/badge.svg)](https://github.com/AlphaNodes/mysql2postgres/actions/workflows/tests.yml)
 
-The minimum Ruby version supported in `main` branch is `2.7`,
-and the next release will have the same requirement.
+Convert MySQL database to PostgreSQL database.
 
 ## Requirements
 
@@ -22,16 +21,22 @@ gem 'mysql2postgres'
 Configuration is written in [YAML format](http://www.yaml.org/ "YAML Ain't Markup Language")
 and passed as the first argument on the command line.
 
-Configuration file has be provided with config/database.yml, see config/default.database.yml for
-an example.
+Configuration file has be provided with config/database.yml, see [config/default.database.yml](config/default.database.yml) for an example and for configuration information.
 
 ## Usage
 
 After providing settings, start migration with
 
 ```sh
+# set destination to use
+MYSQL2POSTGRES_ENV=test
+# use can also use (MYSQL2POSTGRES_ENV is used, if both are defined)
+RAILS_ENV=test
 
+# with default configuration, which use config/database.yml
 bundle exec mysql2postgres
+# OR with specified configuration file
+bundle exec mysql2postgres /home/you/mysql2postgres.yml
 ```
 
 ## Tests

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 desc 'Run all tests'
 task :test do
-  # Rake::Task['test:units'].invoke
+  Rake::Task['test:units'].invoke
   Rake::Task['test:integration'].invoke
 end
 

data/bin/mysql2postgres

@@ -7,21 +7,13 @@ require 'rubygems'
 require 'bundler/setup'
 require 'mysql2postgres'
 
-CONFIG_FILE = File.join File.dirname(__dir__), 'config', 'database.yml'
+config_file = ARGV.empty? ? File.join(File.dirname(__dir__), 'config', 'database.yml') : File.expand_path(ARGV[0])
 
-file = if ARGV.length.positive?
-         ARGV[0]
-       else
-         CONFIG_FILE
-       end
+raise "'#{config_file}' does not exist" unless FileTest.exist? config_file
 
-unless FileTest.exist?(CONFIG_FILE) || (ARGV.length.positive? && FileTest.exist?(File.expand_path(ARGV[0])))
-  raise "'#{file}' does not exist"
-end
+db_yaml = YAML.safe_load File.read(config_file)
 
-db_yaml = YAML.safe_load File.read(file)
+raise "'#{config_file}' does not contain a mysql configuration directive for conversion" unless db_yaml.key? 'mysql'
+raise "'#{config_file}' does not contain destinations configuration directive for conversion" unless db_yaml.key? 'destinations'
 
-raise "'#{file}' does not contain a mysql configuration directive for conversion" unless db_yaml.key? 'mysql'
-raise "'#{file}' does not contain a destination configuration directive for conversion" unless db_yaml.key? 'destination'
-
-Mysql2postgres.new(db_yaml).convert
+Mysql2postgres.new(db_yaml, config_file).convert

data/lib/mysql2postgres/connection.rb

@@ -3,29 +3,17 @@
 class Mysql2postgres
   class Connection
     attr_reader :conn,
-                :adapter,
                 :hostname,
                 :login,
                 :password,
                 :database,
                 :schema,
                 :port,
-                :environment,
                 :copy_manager,
                 :stream,
                 :is_copying
 
-    def initialize(options)
-      @environment = (ENV['RAILS_ENV'] || 'development').to_sym
-
-      if options[:destination].nil? ||
-         options[:destination].empty? ||
-         options[:destination][environment].nil? ||
-         options[:destination][environment].empty?
-        raise 'Unable to locate PostgreSQL destination environment in the configuration file'
-      end
-
-      pg_options = options[:destination][environment]
+    def initialize(pg_options)
       @hostname = pg_options[:hostname] || 'localhost'
       @login = pg_options[:username]
       @password = pg_options[:password]
@@ -33,18 +21,20 @@ class Mysql2postgres
       @port = (pg_options[:port] || 5432).to_s
 
       @database, @schema = database.split ':'
-      @adapter = pg_options[:adapter] || 'jdbcpostgresql'
 
+      @conn = open
+      raise_nil_connection if conn.nil?
+
+      @is_copying = false
+      @current_statement = ''
+    end
+
+    def open
       @conn = PG::Connection.open dbname: database,
                                   user: login,
                                   password: password,
                                   host: hostname,
                                   port: port
-
-      raise_nil_connection if conn.nil?
-
-      @is_copying = false
-      @current_statement = ''
     end
 
     # ensure that the copy is completed, in case we hadn't seen a '\.' in the data stream.
@@ -120,6 +110,16 @@ class Mysql2postgres
       raise 'No Connection'
     end
 
+    def tables
+      result = run_statement <<~SQL_TABLES
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+      SQL_TABLES
+
+      result.map { |t| t['table_name'] }
+    end
+
     private
 
     def run_statement(statement)

data/lib/mysql2postgres/converter.rb

@@ -16,7 +16,6 @@ class Mysql2postgres
     def initialize(reader, writer, options)
       @reader = reader
       @writer = writer
-      @options = options
       @exclude_tables = options[:exclude_tables] || []
       @only_tables = options[:tables]
       @suppress_data = options[:suppress_data] || false
@@ -28,7 +27,7 @@ class Mysql2postgres
 
     def convert
       tables = reader.tables
-      tables.reject! { |table| exclude_tables.include?(table.name) }
+      tables.reject! { |table| exclude_tables.include? table.name }
       tables.select! { |table| only_tables ? only_tables.include?(table.name) : true }
 
       # preserve order only works, if only_tables are specified

data/lib/mysql2postgres/mysql_reader.rb

@@ -125,7 +125,7 @@ class Mysql2postgres
               @indexes << index
             elsif (match_data = /PRIMARY KEY .*\((.*)\)/.match(line))
               index[:primary] = true
-              index[:columns] = match_data[1].split(',').map { |col| col.strip.delete('`') }
+              index[:columns] = match_data[1].split(',').map { |col| col.strip.delete '`' }
               @indexes << index
             end
           end
@@ -164,6 +164,24 @@ class Mysql2postgres
       end
     end
 
+    attr_reader :mysql
+
+    def initialize(options)
+      @host = options[:mysql][:hostname]
+      @user = options[:mysql][:username]
+      @passwd = options[:mysql][:password]
+      @db = options[:mysql][:database]
+      @port = if options[:mysql][:port]
+                options[:mysql][:port] unless options[:mysql][:port].to_s.empty?
+              else
+                3306
+              end
+      @sock = options[:mysql][:socket] && !options[:mysql][:socket].empty? ? options[:mysql][:socket] : nil
+      @flag = options[:mysql][:flag] && !options[:mysql][:flag].empty? ? options[:mysql][:flag] : nil
+
+      connect
+    end
+
     def connect
       @mysql = ::Mysql.connect @host, @user, @passwd, @db, @port, @sock
       # utf8_unicode_ci :: https://rubydoc.info/gems/ruby-mysql/Mysql/Charset
@@ -197,22 +215,8 @@ class Mysql2postgres
       end
     end
 
-    def initialize(options)
-      @host = options[:mysql][:hostname]
-      @user = options[:mysql][:username]
-      @passwd = options[:mysql][:password]
-      @db = options[:mysql][:database]
-      @port = options[:mysql][:port] || 3306
-      @sock = options[:mysql][:socket] && !options[:mysql][:socket].empty? ? options[:mysql][:socket] : nil
-      @sock = options[:mysql][:flag] && !options[:mysql][:flag].empty? ? options[:mysql][:flag] : nil
-
-      connect
-    end
-
-    attr_reader :mysql
-
     def tables
-      @tables ||= @mysql.query('SHOW TABLES').map { |row| Table.new(self, row.first) }
+      @tables ||= @mysql.query('SHOW TABLES').map { |row| Table.new self, row.first }
     end
 
     def paginated_read(table, page_size)

data/lib/mysql2postgres/postgres_db_writer.rb

@@ -5,14 +5,13 @@ require 'mysql2postgres/connection'
 
 class Mysql2postgres
   class PostgresDbWriter < PostgresFileWriter
-    attr_reader :connection, :filename
+    attr_reader :connection
 
-    def initialize(filename, options)
+    def initialize(file, destination)
       # NOTE: the superclass opens and truncates filename for writing
-      super filename
+      super
 
-      @filename = filename
-      @connection = Connection.new options
+      @connection = Connection.new destination
     end
 
     def inload(path = filename)

data/lib/mysql2postgres/postgres_file_writer.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require 'mysql2postgres/postgres_writer'
+require 'fileutils'
 
 class Mysql2postgres
   class PostgresFileWriter < PostgresWriter
-    def initialize(file)
+    def initialize(file, destination)
       super()
 
+      @filename = file
+      @destination = destination
+
       @f = File.open file, 'w+:UTF-8'
       @f << <<~SQL_HEADER
         -- MySQL 2 PostgreSQL dump\n
@@ -88,7 +92,7 @@ class Mysql2postgres
       @f << columns
 
       if (primary_index = table.indexes.find { |index| index[:primary] })
-        @f << ",\n  CONSTRAINT #{table.name}_pkey PRIMARY KEY(#{primary_index[:columns].map { |col| PG::Connection.quote_ident(col) }.join(', ')})"
+        @f << ",\n  CONSTRAINT #{table.name}_pkey PRIMARY KEY(#{quoted_list primary_index[:columns]})"
       end
 
       @f << <<~SQL_OIDS
@@ -103,7 +107,7 @@ class Mysql2postgres
         @f << <<~SQL_INDEX
           DROP INDEX IF EXISTS #{PG::Connection.quote_ident index[:name]} CASCADE;
           CREATE #{unique}INDEX #{PG::Connection.quote_ident index[:name]}
-          ON #{PG::Connection.quote_ident table.name} (#{index[:columns].map { |col| PG::Connection.quote_ident(col) }.join(', ')});
+          ON #{PG::Connection.quote_ident table.name} (#{quoted_list index[:columns]});
         SQL_INDEX
       end
     end
@@ -113,8 +117,8 @@ class Mysql2postgres
     def write_constraints(table)
       table.foreign_keys.each do |key|
         @f << "ALTER TABLE #{PG::Connection.quote_ident table.name} " \
-              "ADD FOREIGN KEY (#{key[:column].map { |c| PG::Connection.quote_ident(c) }.join(', ')}) " \
-              "REFERENCES #{PG::Connection.quote_ident key[:ref_table]}(#{key[:ref_column].map { |c| PG::Connection.quote_ident(c) }.join(', ')}) " \
+              "ADD FOREIGN KEY (#{quoted_list key[:column]}) " \
+              "REFERENCES #{PG::Connection.quote_ident key[:ref_table]}(#{quoted_list key[:ref_column]}) " \
               "ON UPDATE #{key[:on_update]} ON DELETE #{key[:on_delete]};\n"
       end
     end
@@ -125,7 +129,7 @@ class Mysql2postgres
         -- Data for Name: #{table.name}; Type: TABLE DATA; Schema: public
         --
 
-        COPY "#{table.name}" (#{table.columns.map { |column| PG::Connection.quote_ident(column[:name]) }.join(', ')}) FROM stdin;
+        COPY "#{table.name}" (#{quoted_list(table.columns.map { |m| m[:name] })}) FROM stdin;
       SQL_COPY
 
       reader.paginated_read table, 1000 do |row, _counter|
@@ -139,5 +143,15 @@ class Mysql2postgres
     def close
       @f.close
     end
+
+    def inload
+      puts "\nSkip import to PostgreSQL DB. SQL file created successfully."
+    end
+
+    private
+
+    def quoted_list(list)
+      list.map { |c| PG::Connection.quote_ident c }.join(', ')
+    end
   end
 end

data/lib/mysql2postgres/postgres_writer.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'mysql2postgres/writer'
 
 class Mysql2postgres
-  class PostgresWriter < Writer
+  class PostgresWriter
+    attr_reader :filename, :destination
+
     def column_description(column)
       "#{PG::Connection.quote_ident column[:name]} #{column_type_info column}"
     end
@@ -50,16 +51,21 @@ class Mysql2postgres
              when 'double precision'
                default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default]}" if default
                'double precision'
-             when 'datetime'
+             when 'datetime', 'datetime(6)'
                default = nil
                'timestamp without time zone'
              when 'date'
                default = nil
                'date'
              when 'timestamp'
-               default = ' DEFAULT CURRENT_TIMESTAMP' if column[:default] == 'CURRENT_TIMESTAMP'
-               default = " DEFAULT '1970-01-01 00:00'" if column[:default] == '0000-00-00 00:00'
-               default = " DEFAULT '1970-01-01 00:00:00'" if column[:default] == '0000-00-00 00:00:00'
+               case column[:default]
+               when 'CURRENT_TIMESTAMP'
+                 default = ' DEFAULT CURRENT_TIMESTAMP'
+               when datetime_zero
+                 default = " DEFAULT '#{datetime_zero_fix}'"
+               when datetime_zero(with_seconds: true) # rubocop: disable Style/MethodCallWithArgsParentheses
+                 default = " DEFAULT '#{datetime_zero_fix with_seconds: true}'"
+               end
                'timestamp without time zone'
              when 'time'
                default = ' DEFAULT NOW()' if default
@@ -89,45 +95,74 @@ class Mysql2postgres
         row[index] = Time.at(row[index]).utc.strftime('%H:%M:%S') if column[:type] == 'time' && row[index]
 
         if row[index].is_a? Time
-          row[index] = row[index].to_s.gsub '0000-00-00 00:00', '1970-01-01 00:00'
-          row[index] = row[index].to_s.gsub '0000-00-00 00:00:00', '1970-01-01 00:00:00'
+          row[index] = row[index].to_s.gsub datetime_zero, datetime_zero_fix
+          row[index] = row[index].to_s.gsub datetime_zero(with_seconds: true), datetime_zero_fix(with_seconds: true)
         end
 
         if column_type(column) == 'boolean'
           row[index] = if row[index] == 1
                          't'
+                       elsif row[index]&.zero?
+                         'f'
                        else
-                         row[index].zero? ? 'f' : row[index]
+                         row[index]
                        end
         end
 
-        if row[index].is_a? String
-          row[index] = if column_type(column) == 'bytea'
-                         if column[:name] == 'data'
-                           with_gzip = false
-                           table.columns.each_with_index do |column_data, index_data|
-                             if column_data[:name] == 'compression' && row[index_data] == 'gzip'
-                               with_gzip = true
-                               break
-                             end
-                           end
-                           if with_gzip
-                             PG::Connection.escape_bytea(Zlib::Inflate.inflate(row[index])).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
-                           else
-                             PG::Connection.escape_bytea(row[index]).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
-                           end
-                         else
-                           PG::Connection.escape_bytea(row[index]).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
-                         end
-                       else
-                         row[index].gsub(/\\/, '\\\\\\').gsub(/\n/, '\n').gsub(/\t/, '\t').gsub(/\r/, '\r').gsub(/\0/, '')
-                       end
-        end
+        row[index] = string_data table, row, index, column if row[index].is_a? String
 
         row[index] = '\N' unless row[index]
       end
     end
 
     def truncate(_table) end
+
+    def inload
+      raise "Method 'inload' needs to be overridden..."
+    end
+
+    private
+
+    def datetime_zero(with_seconds: false)
+      datetime_value date: '0000-00-00', with_seconds: with_seconds
+    end
+
+    def datetime_zero_fix(with_seconds: false)
+      datetime_value date: '1970-01-01', with_seconds: with_seconds
+    end
+
+    def datetime_value(date:, with_seconds: false)
+      value = ["#{date} 00:00"]
+      value << '00' if with_seconds
+      value.join ':'
+    end
+
+    def string_data(table, row, index, column)
+      if column_type(column) == 'bytea'
+        if column[:name] == 'data'
+          with_gzip = false
+          table.columns.each_with_index do |column_data, index_data|
+            if column_data[:name] == 'compression' && row[index_data] == 'gzip'
+              with_gzip = true
+              break
+            end
+          end
+
+          escape_bytea(with_gzip ? Zlib::Inflate.inflate(row[index]) : row[index])
+        else
+          escape_bytea row[index]
+        end
+      else
+        escape_data(row[index]).gsub("\n", '\n').gsub("\t", '\t').gsub("\r", '\r').gsub(/\0/, '')
+      end
+    end
+
+    def escape_bytea(data)
+      escape_data(PG::Connection.escape_bytea(data)).gsub("''", "'")
+    end
+
+    def escape_data(value)
+      value.gsub '\\', '\\\\\\'
+    end
   end
 end

data/lib/mysql2postgres/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Mysql2postgres
-  VERSION = '0.3.3'
+  VERSION = '0.4.1'
 end

data/lib/mysql2postgres.rb

@@ -12,7 +12,6 @@ require 'pg/result'
 require 'mysql2postgres/version'
 require 'mysql2postgres/converter'
 require 'mysql2postgres/mysql_reader'
-require 'mysql2postgres/writer'
 require 'mysql2postgres/postgres_writer'
 require 'mysql2postgres/postgres_file_writer'
 require 'mysql2postgres/postgres_db_writer'
@@ -20,42 +19,76 @@ require 'mysql2postgres/postgres_db_writer'
 require 'debug' if ENV.fetch('ENABLE_DEBUG', nil) == '1'
 
 class Mysql2postgres
-  attr_reader :options, :reader, :writer
+  attr_reader :options, :config_file, :reader, :writer
 
-  def initialize(yaml)
+  def initialize(yaml, config_file = nil)
+    @config_file = config_file
     @options = build_options yaml
   end
 
-  def build_options(yaml)
-    yaml.transform_keys(&:to_sym).tap do |opts|
-      opts[:mysql].transform_keys!(&:to_sym)
-      opts[:destination].transform_keys!(&:to_sym)
-      opts[:destination].each do |env, settings|
-        opts[:destination][env] = settings.transform_keys(&:to_sym)
-      end
-    end
-  end
+  def convert
+    @reader = MysqlReader.new options
+
+    puts "mysql2postgres #{Mysql2postgres::VERSION}"
+    puts "Config file: #{config_file}"
+    puts "Dumpfile: #{dump_file}"
+
+    @writer = if to_file?
+                puts 'Target: File'
+                PostgresFileWriter.new dump_file, options[:destination]
+              else
+                puts "Target: PostgreSQL DB (#{adapter})"
+                PostgresDbWriter.new dump_file, options[:destination]
+              end
 
-  def send_file_to_postgres(path)
-    connection = Connection.new options
-    connection.load_file path
+    Converter.new(reader, writer, options).convert
+    File.delete dump_file if options[:remove_dump_file] && File.exist?(dump_file)
   end
 
-  def convert
-    @reader = MysqlReader.new options
+  private
 
-    tag = Time.new.strftime '%Y%m%d-%H%M%S'
+  def adapter
+    if options[:destination][:adapter].nil? || options[:destination][:adapter].empty?
+      'postgresql'
+    else
+      options[:destination][:adapter]
+    end
+  end
 
-    path = './'
-    path = options[:dump_file_directory] if options[:dump_file_directory]
+  def environment
+    if ENV['MYSQL2POSTGRES_ENV']
+      ENV['MYSQL2POSTGRES_ENV']
+    elsif ENV['RAILS_ENV']
+      ENV['RAILS_ENV']
+    else
+      'development'
+    end
+  end
 
-    filename = File.expand_path File.join(path, "output_#{tag}.sql")
-    puts "Dumpfile: #{filename}"
+  def to_file?
+    adapter == 'file'
+  end
 
-    @writer = PostgresDbWriter.new filename, options
+  def build_options(yaml)
+    yaml.transform_keys(&:to_sym).tap do |opts|
+      opts[:mysql].transform_keys!(&:to_sym)
 
-    Converter.new(reader, writer, options).convert
+      destinations = opts.delete :destinations
+      opts[:destination] = destinations[environment]&.transform_keys(&:to_sym)
+
+      if opts[:destination].nil? || opts[:destination].empty?
+        raise "no configuration for environment '#{environment}' in destinations available. Use MYSQL2POSTGRES_ENV or RAILS_ENV."
+      end
+    end
+  end
 
-    File.delete filename if options[:remove_dump_file] && File.exist?(filename)
+  def dump_file
+    @dump_file ||= if to_file? && options[:destination][:filename] && options[:destination][:filename] != ''
+                     options[:destination][:filename]
+                   else
+                     tag = Time.new.strftime '%Y%m%d-%H%M%S'
+                     path = options[:dump_file_directory] || './'
+                     File.expand_path File.join(path, "output_#{tag}.sql")
+                   end
   end
 end

data/mysql2postgres.gemspec

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 lib = File.expand_path '../lib', __FILE__
-puts lib
 $LOAD_PATH.unshift lib unless $LOAD_PATH.include? lib
 require 'mysql2postgres/version'
 
@@ -50,31 +49,28 @@ Gem::Specification.new do |s|
     'lib/mysql2postgres/postgres_db_writer.rb',
     'lib/mysql2postgres/postgres_writer.rb',
     'lib/mysql2postgres/version.rb',
-    'lib/mysql2postgres/writer.rb',
     'mysql2postgres.gemspec',
     'test/fixtures/config_all_options.yml',
+    'test/fixtures/config_min_options.yml',
+    'test/fixtures/config_to_file.yml',
     'test/fixtures/seed_integration_tests.sql',
     'test/integration/convert_to_db_test.rb',
     'test/integration/convert_to_file_test.rb',
     'test/integration/converter_test.rb',
-    'test/integration/mysql_reader_base_test.rb',
+    'test/integration/mysql_reader_connection_test.rb',
     'test/integration/mysql_reader_test.rb',
-    'test/integration/postgres_db_writer_base_test.rb',
+    'test/integration/postgres_db_writer_test.rb',
+    'test/units/mysql_test.rb',
     'test/units/option_test.rb',
     'test/units/postgres_file_writer_test.rb',
     'test/test_helper.rb'
   ]
-  s.homepage = 'https://code.alphanodes.com/alphanodes/mysql2postgres'
+  s.homepage = 'https://github.com/AlphaNodes/mysql2postgres'
   s.rdoc_options = ['--charset=UTF-8']
   s.require_paths = ['lib']
   s.summary = 'MySQL to PostgreSQL Data Translation'
 
-  s.add_dependency 'rake'
   s.add_runtime_dependency 'pg', '~> 1.2.2'
-  s.add_runtime_dependency 'postgres-pr', '~> 0.7'
+  s.add_runtime_dependency 'rake'
   s.add_runtime_dependency 'ruby-mysql', '~> 3.0'
-  s.add_development_dependency 'debug'
-  s.add_development_dependency 'rubocop-minitest'
-  s.add_development_dependency 'rubocop-performance'
-  s.add_development_dependency 'test-unit', '~> 3.5.3'
 end