pgsync 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af75f9e9eb115a889d53b10ed89d8355e3ef111868b69eec31a025a8f22db27e
-  data.tar.gz: 5da0d56267ac89f2ffc282e92275a91d3fb83d80fe969207329ec8ce1876472b
+  metadata.gz: f1c278b92d9c3c7848f655be4148555df1739194e959b8aff56ef39228c2656d
+  data.tar.gz: e2620166fef4fd1a785863d28796390ee4c29a7bc301a7b32800116306d9a15b
 SHA512:
-  metadata.gz: 9f9d78aebf02f75a5fee9413b56bba68ed97334b3134cef5c28f4b5a8a15cbab45e752cb73dcd88028e2b3b2b0fefb20ef9bd4abe0c92d35998a520b0029e961
-  data.tar.gz: a2fdaee8ba32df378ed2538119817b7649fe134a33c0f6013d55d8e1cb76ae6b0a75d3dd10dff4872d0452bc2e41bb0024c5f276f16ed8f0d1c81b114574f757
+  metadata.gz: bcd912263fce83a965d790eed4af30f59227b2b55e82cc46e90c109df8c1e3a6e0d7d25f29d14c946bbdc578a3817373a4eac938fe75282586d939a2fba522ea
+  data.tar.gz: 4606494cd7608080cf7863432eaeee6ab1a49fba221ef82da906ccce264e07003eb6458600134f398bb717e556b83339b0b2362d55d7bb62a21ee645678c653f

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.5.3 (2020-04-03)
+
+- Improved Postgres error messages
+- Fixed behavior of wildcard without schema
+
 ## 0.5.2 (2020-03-27)
 
 - Added `--fail-fast` option

data/exe/pgsync

@@ -1,9 +1,5 @@
 #!/usr/bin/env ruby
 
-# disable Slop warning with Ruby 2.7
-# TODO remove when Slop > 4.7.0 is released
-$VERBOSE = nil
-
 # handle interrupts
 trap("SIGINT") { abort }
 

data/lib/pgsync/client.rb

@@ -4,12 +4,15 @@ module PgSync
 
     def initialize(args)
       @args = args
-      $stderr.sync = true
+      output.sync = true
     end
 
     def perform(testing: true)
       opts = parse_args
 
+      # TODO throw error in 0.6.0
+      warn "Specify either --db or --config, not both" if opts[:db] && opts[:config]
+
       if opts.version?
         log VERSION
       elsif opts.help?
@@ -22,7 +25,7 @@ module PgSync
       end
     rescue Error, PG::ConnectionBad => e
       raise e if testing
-      abort colorize(e.message, 31) # red
+      abort colorize(e.message, :red)
     end
 
     def self.start

data/lib/pgsync/init.rb

@@ -12,7 +12,7 @@ module PgSync
         raise Error, "#{file} exists."
       else
         exclude =
-          if rails_app?
+          if rails?
             <<~EOS
               exclude:
                 - schema_migrations
@@ -21,21 +21,25 @@ module PgSync
           else
             <<~EOS
               # exclude:
-              #   - schema_migrations
-              #   - ar_internal_metadata
+              #   - table1
+              #   - table2
             EOS
           end
 
         # create file
         contents = File.read(__dir__ + "/../../config.yml")
+        contents.sub!("$(some_command)", "$(heroku config:get DATABASE_URL)") if heroku?
         File.write(file, contents % {exclude: exclude})
 
         log "#{file} created. Add your database credentials."
       end
     end
 
-    # TODO maybe check parent directories
-    def rails_app?
+    def heroku?
+      `git remote -v 2>&1`.include?("git.heroku.com") rescue false
+    end
+
+    def rails?
       File.exist?("bin/rails")
     end
   end

data/lib/pgsync/sync.rb

@@ -138,9 +138,10 @@ module PgSync
 
     def config
       @config ||= begin
-        if config_file
+        file = config_file
+        if file
           begin
-            YAML.load_file(config_file) || {}
+            YAML.load_file(file) || {}
           rescue Psych::SyntaxError => e
             raise Error, e.message
           end
@@ -156,15 +157,14 @@ module PgSync
     end
 
     def in_parallel(tables, first_schema:, &block)
-      spinners = TTY::Spinner::Multi.new(format: :dots)
+      spinners = TTY::Spinner::Multi.new(format: :dots, output: output)
       item_spinners = {}
 
       start = lambda do |item, i|
         table, opts = item
         message = String.new(":spinner ")
         message << table.sub("#{first_schema}.", "")
-        # maybe output later
-        # message << " #{opts[:sql]}" if opts[:sql]
+        message << " #{opts[:sql]}" if opts[:sql]
         spinner = spinners.register(message)
         spinner.auto_spin
         item_spinners[item] = spinner
@@ -187,7 +187,7 @@ module PgSync
 
         unless spinner.send(:tty?)
           status = result[:status] == "success" ? "✔" : "✖"
-          log [status, table_name, display_message(result)].compact.join(" ")
+          log [status, table_name, item.last[:sql], display_message(result)].compact.join(" ")
         end
       end
 
@@ -213,7 +213,7 @@ module PgSync
     def display_message(result)
       messages = []
       messages << "- #{result[:time]}s" if result[:time]
-      messages << "(#{result[:message].gsub("\n", " ").strip})" if result[:message]
+      messages << "(#{result[:message].lines.first.to_s.strip})" if result[:message]
       messages.join(" ")
     end
 
@@ -224,13 +224,13 @@ module PgSync
     end
 
     def deprecated(message)
-      log colorize("[DEPRECATED] #{message}", 33) # yellow
+      log colorize("[DEPRECATED] #{message}", :yellow)
     end
 
     def log_completed(start_time)
       time = Time.now - start_time
       message = "Completed in #{time.round(1)}s"
-      log colorize(message, 32) # green
+      log colorize(message, :green)
     end
 
     def windows?

data/lib/pgsync/table_list.rb

@@ -9,49 +9,58 @@ module PgSync
       @opts = options
       @source = source
       @config = config
+      @groups = config["groups"] || {}
+    end
+
+    def group?(group)
+      @groups.key?(group)
     end
 
     def tables
-      tables = nil
+      tables = {}
+      sql = args[1]
 
-      if opts[:groups]
-        tables ||= Hash.new { |hash, key| hash[key] = {} }
-        specified_groups = to_arr(opts[:groups])
-        specified_groups.map do |tag|
+      groups = to_arr(opts[:groups])
+      tables2 = to_arr(opts[:tables])
+
+      if args[0]
+        # could be a group, table, or mix
+        to_arr(args[0]).each do |tag|
           group, id = tag.split(":", 2)
-          if (t = (config["groups"] || {})[group])
-            add_tables(tables, t, id, args[1])
+          if group?(group)
+            groups << tag
           else
-            raise Error, "Group not found: #{group}"
+            tables2 << tag
           end
         end
       end
 
-      if opts[:tables]
-        tables ||= Hash.new { |hash, key| hash[key] = {} }
-        to_arr(opts[:tables]).each do |tag|
-          table, id = tag.split(":", 2)
-          raise Error, "Cannot use parameters with tables" if id
-          add_table(tables, table, id, args[1])
-        end
-      end
+      groups.each do |tag|
+        group, id = tag.split(":", 2)
+        raise Error, "Group not found: #{group}" unless group?(group)
 
-      if args[0]
-        # could be a group, table, or mix
-        tables ||= Hash.new { |hash, key| hash[key] = {} }
-        specified_groups = to_arr(args[0])
-        specified_groups.map do |tag|
-          group, id = tag.split(":", 2)
-          if (t = (config["groups"] || {})[group])
-            add_tables(tables, t, id, args[1])
-          else
-            raise Error, "Cannot use parameters with tables" if id
-            add_table(tables, group, id, args[1])
+        # if id
+        #   # TODO show group name and value
+        #   log colorize("`pgsync group:value` is deprecated and will have a different function in 0.6.0.", :yellow)
+        #   log colorize("Use `pgsync group --var 1=value` instead.", :yellow)
+        # end
+
+        @groups[group].each do |table|
+          table_sql = nil
+          if table.is_a?(Array)
+            table, table_sql = table
           end
+          add_table(tables, table, id, sql || table_sql)
         end
       end
 
-      tables ||= begin
+      tables2.each do |tag|
+        table, id = tag.split(":", 2)
+        raise Error, "Cannot use parameters with tables" if id
+        add_table(tables, table, id, sql)
+      end
+
+      if !opts[:groups] && !opts[:tables] && !args[0]
         exclude = to_arr(opts[:exclude])
         exclude = source.fully_resolve_tables(exclude).keys if exclude.any?
 
@@ -61,7 +70,9 @@ module PgSync
           tabs.select! { |t| schemas.include?(t.split(".", 2)[0]) }
         end
 
-        Hash[(tabs - exclude).map { |k| [k, {}] }]
+        (tabs - exclude).each do |k|
+          tables[k] = {}
+        end
       end
 
       source.fully_resolve_tables(tables)
@@ -79,60 +90,47 @@ module PgSync
       end
     end
 
-    def add_tables(tables, t, id, boom)
-      # if id
-      #   # TODO show group name and value
-      #   log colorize("`pgsync group:value` is deprecated and will have a different function in 0.6.0.", 33) # yellow
-      #   log colorize("Use `pgsync group --var 1=value` instead.", 33) # yellow
-      # end
-
-      t.each do |table|
-        sql = nil
-        if table.is_a?(Array)
-          table, sql = table
+    def add_table(tables, table, id, sql)
+      tables2 =
+        if table.include?("*")
+          regex = Regexp.new('\A' + Regexp.escape(table).gsub('\*','[^\.]*') + '\z')
+          source.tables.select { |t| regex.match(t) || regex.match(t.split(".", 2).last) }
+        else
+          [table]
         end
-        add_table(tables, table, id, boom || sql)
+
+      tables2.each do |tab|
+        tables[tab] = {}
+        tables[tab][:sql] = table_sql(sql, id) if sql
       end
     end
 
-    def add_table(tables, table, id, boom, wildcard = false)
-      if table.include?("*") && !wildcard
-        regex = Regexp.new('\A' + Regexp.escape(table).gsub('\*','[^\.]*') + '\z')
-        t2 = source.tables.select { |t| regex.match(t) }
-        t2.each do |tab|
-          add_table(tables, tab, id, boom, true)
-        end
-      else
-        tables[table] = {}
-        if boom
-          sql = boom.dup
-          # vars must match \w
-          missing_vars = sql.scan(/{\w+}/).map { |v| v[1..-2] }
-
-          vars = {}
-
-          # legacy
-          if id
-            vars["id"] = cast(id)
-            vars["1"] = cast(id)
-          end
+    def table_sql(sql, id)
+      # vars must match \w
+      missing_vars = sql.scan(/{\w+}/).map { |v| v[1..-2] }
 
-          # opts[:var].each do |value|
-          #   k, v = value.split("=", 2)
-          #   vars[k] = v
-          # end
+      vars = {}
 
-          sql = boom.dup
-          vars.each do |k, v|
-            # only sub if in var list
-            sql.gsub!("{#{k}}", cast(v)) if missing_vars.delete(k)
-          end
+      # legacy
+      if id
+        vars["id"] = cast(id)
+        vars["1"] = cast(id)
+      end
 
-          raise Error, "Missing variables: #{missing_vars.uniq.join(", ")}" if missing_vars.any?
+      # opts[:var].each do |value|
+      #   k, v = value.split("=", 2)
+      #   vars[k] = v
+      # end
 
-          tables[table][:sql] = sql
-        end
+      sql = sql.dup
+      vars.each do |k, v|
+        # only sub if in var list
+        sql.gsub!("{#{k}}", cast(v)) if missing_vars.delete(k)
       end
+
+      raise Error, "Missing variables: #{missing_vars.uniq.join(", ")}" if missing_vars.any?
+
+      sql
     end
 
     # TODO quote vars in next major version

data/lib/pgsync/table_sync.rb

@@ -4,173 +4,150 @@ module PgSync
 
     def sync(config, table, opts, source_url, destination_url)
       start_time = Time.now
+
       source = DataSource.new(source_url, timeout: 0)
       destination = DataSource.new(destination_url, timeout: 0)
 
-      begin
-        from_connection = source.conn
-        to_connection = destination.conn
-
-        bad_fields = opts[:no_rules] ? [] : config["data_rules"]
-
-        from_fields = source.columns(table)
-        to_fields = destination.columns(table)
-        shared_fields = to_fields & from_fields
-        extra_fields = to_fields - from_fields
-        missing_fields = from_fields - to_fields
+      from_connection = source.conn
+      to_connection = destination.conn
 
-        if opts[:no_sequences]
-          from_sequences = []
-          to_sequences = []
-        else
-          from_sequences = source.sequences(table, shared_fields)
-          to_sequences = destination.sequences(table, shared_fields)
-        end
+      from_fields = source.columns(table)
+      to_fields = destination.columns(table)
+      shared_fields = to_fields & from_fields
+      extra_fields = to_fields - from_fields
+      missing_fields = from_fields - to_fields
 
-        shared_sequences = to_sequences & from_sequences
-        extra_sequences = to_sequences - from_sequences
-        missing_sequences = from_sequences - to_sequences
+      if opts[:no_sequences]
+        from_sequences = []
+        to_sequences = []
+      else
+        from_sequences = source.sequences(table, shared_fields)
+        to_sequences = destination.sequences(table, shared_fields)
+      end
 
-        sql_clause = String.new
+      shared_sequences = to_sequences & from_sequences
+      extra_sequences = to_sequences - from_sequences
+      missing_sequences = from_sequences - to_sequences
 
-        if opts[:sql]
-          sql_clause << " #{opts[:sql]}"
-        end
+      sql_clause = String.new("")
+      sql_clause << " #{opts[:sql]}" if opts[:sql]
 
-        notes = []
-        notes << "Extra columns: #{extra_fields.join(", ")}" if extra_fields.any?
-        notes << "Missing columns: #{missing_fields.join(", ")}" if missing_fields.any?
-        notes << "Extra sequences: #{extra_sequences.join(", ")}" if extra_sequences.any?
-        notes << "Missing sequences: #{missing_sequences.join(", ")}" if missing_sequences.any?
+      notes = []
+      notes << "Extra columns: #{extra_fields.join(", ")}" if extra_fields.any?
+      notes << "Missing columns: #{missing_fields.join(", ")}" if missing_fields.any?
+      notes << "Extra sequences: #{extra_sequences.join(", ")}" if extra_sequences.any?
+      notes << "Missing sequences: #{missing_sequences.join(", ")}" if missing_sequences.any?
 
-        if shared_fields.empty?
-          return {status: "success", message: "No fields to copy"}
-        end
+      return {status: "success", message: "No fields to copy"} if shared_fields.empty?
 
-        if shared_fields.any?
-          primary_key = destination.primary_key(table)
-          copy_fields = shared_fields.map { |f| f2 = bad_fields.to_a.find { |bf, _| rule_match?(table, f, bf) }; f2 ? "#{apply_strategy(f2[1], table, f, primary_key)} AS #{quote_ident(f)}" : "#{quote_ident_full(table)}.#{quote_ident(f)}" }.join(", ")
-          fields = shared_fields.map { |f| quote_ident(f) }.join(", ")
+      bad_fields = opts[:no_rules] ? [] : config["data_rules"]
+      primary_key = destination.primary_key(table)
+      copy_fields = shared_fields.map { |f| f2 = bad_fields.to_a.find { |bf, _| rule_match?(table, f, bf) }; f2 ? "#{apply_strategy(f2[1], table, f, primary_key)} AS #{quote_ident(f)}" : "#{quote_ident_full(table)}.#{quote_ident(f)}" }.join(", ")
+      fields = shared_fields.map { |f| quote_ident(f) }.join(", ")
 
-          seq_values = {}
-          shared_sequences.each do |seq|
-            seq_values[seq] = source.last_value(seq)
-          end
+      seq_values = {}
+      shared_sequences.each do |seq|
+        seq_values[seq] = source.last_value(seq)
+      end
 
-          copy_to_command = "COPY (SELECT #{copy_fields} FROM #{quote_ident_full(table)}#{sql_clause}) TO STDOUT"
-          if opts[:in_batches]
-            raise Error, "Cannot use --overwrite with --in-batches" if opts[:overwrite]
-            raise Error, "No primary key" unless primary_key
+      copy_to_command = "COPY (SELECT #{copy_fields} FROM #{quote_ident_full(table)}#{sql_clause}) TO STDOUT"
+      if opts[:in_batches]
+        raise Error, "Cannot use --overwrite with --in-batches" if opts[:overwrite]
+        raise Error, "No primary key" unless primary_key
 
-            destination.truncate(table) if opts[:truncate]
+        destination.truncate(table) if opts[:truncate]
 
-            from_max_id = source.max_id(table, primary_key)
-            to_max_id = destination.max_id(table, primary_key) + 1
+        from_max_id = source.max_id(table, primary_key)
+        to_max_id = destination.max_id(table, primary_key) + 1
 
-            if to_max_id == 1
-              from_min_id = source.min_id(table, primary_key)
-              to_max_id = from_min_id if from_min_id > 0
-            end
+        if to_max_id == 1
+          from_min_id = source.min_id(table, primary_key)
+          to_max_id = from_min_id if from_min_id > 0
+        end
 
-            starting_id = to_max_id
-            batch_size = opts[:batch_size]
+        starting_id = to_max_id
+        batch_size = opts[:batch_size]
 
-            i = 1
-            batch_count = ((from_max_id - starting_id + 1) / batch_size.to_f).ceil
+        i = 1
+        batch_count = ((from_max_id - starting_id + 1) / batch_size.to_f).ceil
 
-            while starting_id <= from_max_id
-              where = "#{quote_ident(primary_key)} >= #{starting_id} AND #{quote_ident(primary_key)} < #{starting_id + batch_size}"
-              log "    #{i}/#{batch_count}: #{where}"
+        while starting_id <= from_max_id
+          where = "#{quote_ident(primary_key)} >= #{starting_id} AND #{quote_ident(primary_key)} < #{starting_id + batch_size}"
+          log "    #{i}/#{batch_count}: #{where}"
 
-              # TODO be smarter for advance sql clauses
-              batch_sql_clause = " #{sql_clause.length > 0 ? "#{sql_clause} AND" : "WHERE"} #{where}"
+          # TODO be smarter for advance sql clauses
+          batch_sql_clause = " #{sql_clause.length > 0 ? "#{sql_clause} AND" : "WHERE"} #{where}"
 
-              batch_copy_to_command = "COPY (SELECT #{copy_fields} FROM #{quote_ident_full(table)}#{batch_sql_clause}) TO STDOUT"
-              to_connection.copy_data "COPY #{quote_ident_full(table)} (#{fields}) FROM STDIN" do
-                from_connection.copy_data batch_copy_to_command do
-                  while (row = from_connection.get_copy_data)
-                    to_connection.put_copy_data(row)
-                  end
-                end
-              end
-
-              starting_id += batch_size
-              i += 1
-
-              if opts[:sleep] && starting_id <= from_max_id
-                sleep(opts[:sleep])
+          batch_copy_to_command = "COPY (SELECT #{copy_fields} FROM #{quote_ident_full(table)}#{batch_sql_clause}) TO STDOUT"
+          to_connection.copy_data "COPY #{quote_ident_full(table)} (#{fields}) FROM STDIN" do
+            from_connection.copy_data batch_copy_to_command do
+              while (row = from_connection.get_copy_data)
+                to_connection.put_copy_data(row)
               end
             end
+          end
 
-            log # add extra line for spinner
-          elsif !opts[:truncate] && (opts[:overwrite] || opts[:preserve] || !sql_clause.empty?)
-            raise Error, "No primary key" unless primary_key
-
-            temp_table = "pgsync_#{rand(1_000_000_000)}"
-            file = Tempfile.new(temp_table)
-            begin
-              from_connection.copy_data copy_to_command do
-                while (row = from_connection.get_copy_data)
-                  file.write(row)
-                end
-              end
-              file.rewind
+          starting_id += batch_size
+          i += 1
+
+          if opts[:sleep] && starting_id <= from_max_id
+            sleep(opts[:sleep])
+          end
+        end
 
-              # create a temp table
-              to_connection.exec("CREATE TEMPORARY TABLE #{quote_ident_full(temp_table)} AS SELECT * FROM #{quote_ident_full(table)} WITH NO DATA")
+        log # add extra line for spinner
+      elsif !opts[:truncate] && (opts[:overwrite] || opts[:preserve] || !sql_clause.empty?)
+        raise Error, "No primary key" unless primary_key
 
-              # load file
-              to_connection.copy_data "COPY #{quote_ident_full(temp_table)} (#{fields}) FROM STDIN" do
-                file.each do |row|
-                  to_connection.put_copy_data(row)
-                end
-              end
+        # create a temp table
+        temp_table = "pgsync_#{rand(1_000_000_000)}"
+        to_connection.exec("CREATE TEMPORARY TABLE #{quote_ident_full(temp_table)} AS SELECT * FROM #{quote_ident_full(table)} WITH NO DATA")
 
-              if opts[:preserve]
-                # insert into
-                to_connection.exec("INSERT INTO #{quote_ident_full(table)} (SELECT * FROM #{quote_ident_full(temp_table)} WHERE NOT EXISTS (SELECT 1 FROM #{quote_ident_full(table)} WHERE #{quote_ident_full(table)}.#{quote_ident(primary_key)} = #{quote_ident_full(temp_table)}.#{quote_ident(primary_key)}))")
-              else
-                to_connection.transaction do
-                  to_connection.exec("DELETE FROM #{quote_ident_full(table)} WHERE #{quote_ident(primary_key)} IN (SELECT #{quote_ident(primary_key)} FROM #{quote_ident_full(temp_table)})")
-                  to_connection.exec("INSERT INTO #{quote_ident_full(table)} (SELECT * FROM #{quote_ident(temp_table)})")
-                end
-              end
-            ensure
-               file.close
-               file.unlink
-            end
-          else
-            destination.truncate(table)
-            to_connection.copy_data "COPY #{quote_ident_full(table)} (#{fields}) FROM STDIN" do
-              from_connection.copy_data copy_to_command do
-                while (row = from_connection.get_copy_data)
-                  to_connection.put_copy_data(row)
-                end
-              end
+        # load data
+        to_connection.copy_data "COPY #{quote_ident_full(temp_table)} (#{fields}) FROM STDIN" do
+          from_connection.copy_data copy_to_command do
+            while (row = from_connection.get_copy_data)
+              to_connection.put_copy_data(row)
             end
           end
-          seq_values.each do |seq, value|
-            to_connection.exec("SELECT setval(#{escape(seq)}, #{escape(value)})")
-          end
         end
 
-        message = nil
-        if notes.any?
-          message = notes.join(", ")
+        if opts[:preserve]
+          # insert into
+          to_connection.exec("INSERT INTO #{quote_ident_full(table)} (SELECT * FROM #{quote_ident_full(temp_table)} WHERE NOT EXISTS (SELECT 1 FROM #{quote_ident_full(table)} WHERE #{quote_ident_full(table)}.#{quote_ident(primary_key)} = #{quote_ident_full(temp_table)}.#{quote_ident(primary_key)}))")
+        else
+          to_connection.transaction do
+            to_connection.exec("DELETE FROM #{quote_ident_full(table)} WHERE #{quote_ident(primary_key)} IN (SELECT #{quote_ident(primary_key)} FROM #{quote_ident_full(temp_table)})")
+            to_connection.exec("INSERT INTO #{quote_ident_full(table)} (SELECT * FROM #{quote_ident(temp_table)})")
+          end
         end
-
-        {status: "success", message: message, time: (Time.now - start_time).round(1)}
-      ensure
-        source.close
-        destination.close
+      else
+        destination.truncate(table)
+        to_connection.copy_data "COPY #{quote_ident_full(table)} (#{fields}) FROM STDIN" do
+          from_connection.copy_data copy_to_command do
+            while (row = from_connection.get_copy_data)
+              to_connection.put_copy_data(row)
+            end
+          end
+        end
+      end
+      seq_values.each do |seq, value|
+        to_connection.exec("SELECT setval(#{escape(seq)}, #{escape(value)})")
       end
+
+      message = nil
+      message = notes.join(", ") if notes.any?
+
+      {status: "success", message: message, time: (Time.now - start_time).round(1)}
     rescue => e
       message =
         case e
-        when PG::Error
+        when PG::ConnectionBad
           # likely fine to show simplified message here
           # the full message will be shown when first trying to connect
           "Connection failed"
+        when PG::Error
+          e.message.sub("ERROR:  ", "")
         when Error
           e.message
         else
@@ -178,6 +155,9 @@ module PgSync
         end
 
       {status: "error", message: message}
+    ensure
+      source.close if source
+      destination.close if destination
     end
 
     private

data/lib/pgsync/utils.rb

@@ -1,43 +1,43 @@
 module PgSync
   module Utils
+    COLOR_CODES = {
+      red: 31,
+      green: 32,
+      yellow: 33
+    }
+
     def log(message = nil)
-      $stderr.puts message
+      output.puts message
     end
 
-    def colorize(message, color_code)
-      if $stderr.tty?
-        "\e[#{color_code}m#{message}\e[0m"
+    def colorize(message, color)
+      if output.tty?
+        "\e[#{COLOR_CODES[color]}m#{message}\e[0m"
       else
         message
       end
     end
 
-    def config_file
-      return @config_file if instance_variable_defined?(:@config_file)
+    def output
+      $stderr
+    end
 
-      @config_file =
-        search_tree(
-          if @options[:db]
-            db_config_file(@options[:db])
-          else
-            @options[:config] || ".pgsync.yml"
-          end
-        )
+    def config_file
+      search_tree(db_config_file(@options[:db]) || @options[:config] || ".pgsync.yml")
     end
 
     def db_config_file(db)
-      return unless db
-      ".pgsync-#{db}.yml"
+      ".pgsync-#{db}.yml" if db
     end
 
     def search_tree(file)
+      return file if File.exists?(file)
+
       path = Dir.pwd
       # prevent infinite loop
       20.times do
         absolute_file = File.join(path, file)
-        if File.exist?(absolute_file)
-          break absolute_file
-        end
+        break absolute_file if File.exist?(absolute_file)
         path = File.dirname(path)
         break if path == "/"
       end

data/lib/pgsync/version.rb

@@ -1,3 +1,3 @@
 module PgSync
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgsync
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-28 00:00:00.000000000 Z
+date: 2020-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 4.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 4.8.1
 - !ruby/object:Gem::Dependency
   name: tty-spinner
   requirement: !ruby/object:Gem::Requirement