pg_shrink 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 117e596cf13247f02367b4a68c567e992af5be2a
-  data.tar.gz: 923fdb14ee56b247545369797a6bdca7408d8953
+  metadata.gz: 79d28599347bf3d3b21a5ff1066eb005d93de451
+  data.tar.gz: 52afef4d72dfe607d9a6b9fea197789492a27153
 SHA512:
-  metadata.gz: 8e4d119d4f47a29027e52b7311b04e2232b87510245ef09f727dbfc9d9b32472f6f07bb6dd2fd4287994147078a61b9ca3e06389a8d0fb084965ff642618a05c
-  data.tar.gz: 279662e61bb4fdfef90de4ed31f01ea2cad82f5c52460f27fff5223028ad979a309cb843863f042beaf9e9c825b3f6003c3bdc50ba0a94bfeab5c08d0b3c2913
+  metadata.gz: b34ea492d943779dafde384932065fdaae0d5244ff09b115c5436a319c27bdccae5ac01c02dcfda578a54a3383b725f561c5333fc199efd8e91dae81ad542303
+  data.tar.gz: b3c7736462f971e4eba50960a48dea9260c891d1b0152c7fe675669213ac241e459a9dce38f6a32cdfb8e5765d17a898e78ed756aa95abe4476cb233f8aad103

data/README.md

@@ -1,5 +1,4 @@
-[![Build Status](https://travis-ci.org/apartmentlist/pg-shrink.svg?branch=master)](https://travis-ci.org/apartmentlist/pg-shrink)
-
+[![Build Status](https://travis-ci.org/apartmentlist/pg_shrink.svg?branch=master)](https://travis-ci.org/apartmentlist/pg_shrink)
 # PgShrink
 
 The pg_shrink tool makes it easy to shrink and sanitize a postgres database,

data/Shrinkfile.example

@@ -23,11 +23,16 @@ filter_table :users do |f|
   f.filter_subtable(:email_preferences, :foreign_key => :user_email,
                                         :primary_key => :email)
 
-  # You can also filter by a polymorphic reference by specifying the
-  # type_key and type.
-  f.filter_subtable(:polymorphic_referneces, :foreign_key => :context_id,
-                                             :type_key => :context_type,
-                                             :type => 'User')
+  # You can also pass an additional where clause expression that restricts
+  # filtering propagation to certain subset of rows. This allows to support
+  # polymorphic relationships, or STI.
+  f.filter_subtable(:email_preferences, foreign_key: user_id,
+                                        where: "type = 'User::Registered'")
+
+  # 'where' clause can be anything that sequel supports
+  f.filter_subtable(:email_preferences, foreign_key: user_id,
+                                              where: {  type: 'User::Registered',
+                                                       color: 'Red'})
 
   # If it feels more natural, you can define additional filters
   # within a filter_subtable definitition

data/lib/pg_shrink/database/postgres.rb

@@ -113,31 +113,33 @@ module PgShrink
     end
 
     def propagate_delete(opts)
+
+      child_table = opts[:child_table]
+      parent_table = opts[:parent_table]
+      child_key = opts[:child_key]
+      parent_key = opts[:parent_key]
+      where_clause = opts[:where]
+
       # what we conceptually want to do is delete the left outer join where id is null.
       # That's not working in postgres, so we instead use where not exists.  Docs
       # indicate using where not exists and select 1 in this case.
       # See:
       # http://www.postgresql.org/docs/current/interactive/functions-subquery.html#FUNCTIONS-SUBQUERY-EXISTS
-      query = "DELETE FROM #{opts[:child_table]} WHERE NOT EXISTS (" +
-                "SELECT 1 from #{opts[:parent_table]} where " +
-                "#{opts[:child_table]}.#{opts[:child_key]} = " +
-                "#{opts[:parent_table]}.#{opts[:parent_key]}" +
+      query = "DELETE FROM #{child_table} WHERE NOT EXISTS (" +
+                "SELECT 1 from #{parent_table} where " +
+                "#{child_table}.#{child_key} = " +
+                "#{parent_table}.#{parent_key}" +
               ")"
 
+      query_builder = connection.from(child_table)
+      query_builder = query_builder.where(where_clause) if where_clause
 
       # Outside of the join statements, we want to maintain the ease of hash-based
       # conditions.  Do this by using a query builder but then swapping in delete SQL
       # in the end.
-      query_builder = connection.from(opts[:child_table])
-      Array.wrap(opts[:conditions]).compact.each do |cond|
-        query_builder = query_builder.where(cond)
-      end
-      Array.wrap(opts[:exclude]).compact.each do |exclude_cond|
-        query_builder = query_builder.exclude(exclude_cond)
-      end
+
       sql = query_builder.sql.gsub("WHERE", "AND").
-                              gsub("SELECT * FROM \"#{opts[:child_table]}\"",
-                                   query)
+                              gsub("SELECT * FROM \"#{child_table}\"", query)
 
       connection[sql].delete
     end

data/lib/pg_shrink/sub_table_filter.rb

@@ -4,42 +4,25 @@ module PgShrink
     def propagate_table!
       primary_key = @opts[:primary_key]
       foreign_key = @opts[:foreign_key]
-      additional_conditions = {}
-      if @opts[:type_key] && @opts[:type]
-        additional_conditions[@opts[:type_key]] = @opts[:type]
-      end
-      self.database.log("Beginning subtable propagation from " +
+      where_clause = @opts[:where]
+
+      self.database.log('Beginning subtable propagation from ' +
                "#{self.parent.table_name} to #{self.table.table_name}")
-      self.database.propagate_delete(:parent_table => self.parent.table_name,
-                                     :child_table => self.table.table_name,
-                                     :parent_key => primary_key,
-                                     :child_key => foreign_key,
-                                     :conditions => additional_conditions)
 
-      self.database.log("Done with subtable propagation from " +
+      self.database.propagate_delete(parent_table: self.parent.table_name,
+                                     child_table: self.table.table_name,
+                                     parent_key: primary_key,
+                                     child_key: foreign_key,
+                                     where: where_clause)
+
+      self.database.log('Done with subtable propagation from ' +
                "#{self.parent.table_name} to #{self.table.table_name}")
+
       if self.table.subtable_filters.any?
         self.database.vacuum_and_reindex!(self.table.table_name)
         self.table.subtable_filters.each(&:propagate_table!)
       end
     end
 
-    def propagate!(old_parent_data, new_parent_data)
-      return if (old_parent_data.empty? && new_parent_data.empty?)
-      old_batch_keys = old_parent_data.map {|record| record[@opts[:primary_key]]}
-      new_batch_keys = new_parent_data.map {|record| record[@opts[:primary_key]]}
-
-      foreign_key = @opts[:foreign_key]
-      finder_options = {foreign_key => old_batch_keys}
-      if @opts[:type_key] && @opts[:type]
-        finder_options[@opts[:type_key]] = @opts[:type]
-      end
-
-      old_records = table.get_records(finder_options)
-      table.filter_batch(old_records) do |record|
-        new_batch_keys.include?(record[foreign_key])
-      end
-    end
-
   end
 end

data/lib/pg_shrink/sub_table_operator.rb

@@ -2,9 +2,10 @@ module PgShrink
   class SubTableOperator
     attr_accessor :parent, :table_name, :database
     def default_opts
-      {:foreign_key =>
+      {
+        :foreign_key =>
         "#{ActiveSupport::Inflector.singularize(parent.table_name.to_s)}_id",
-       :primary_key => :id
+        :primary_key => :id
       }
     end
 
@@ -16,15 +17,6 @@ module PgShrink
       database.table(table_name)
     end
 
-    def validate_opts!(opts)
-      if opts[:type_key] && !opts[:type]
-        raise "Error:  #{name} has type_key set but no type"
-      end
-      if opts[:type] && !opts[:type_key]
-        raise "Error:  #{name} has type set but no type_key"
-      end
-    end
-
     def initialize(parent, table_name, opts = {})
       self.parent = parent
       self.table_name = table_name
@@ -34,6 +26,8 @@ module PgShrink
       validate_opts!(@opts)
     end
 
+    def validate_opts!(opts); end
+
     def propagate!(old_parent_data, new_parent_data)
       raise "Implement in subclass"
     end

data/lib/pg_shrink/sub_table_sanitizer.rb

@@ -15,9 +15,10 @@ module PgShrink
 
       foreign_key = @opts[:foreign_key]
       finder_options = {foreign_key => old_batch.keys}
-      if @opts[:type_key] && @opts[:type]
-        finder_options[@opts[:type_key]] = @opts[:type]
-      end
+
+      # adding additional filters from where clause.
+      # TODO: support where clauses using non hash syntax (string, symbol)
+      finder_options.merge!(@opts[:where])
 
       parent_field = @opts[:local_field].to_sym
       child_field = @opts[:foreign_field].to_sym

data/lib/pg_shrink/version.rb

@@ -1,3 +1,3 @@
 module PgShrink
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/pg_shrink.gemspec

@@ -6,11 +6,11 @@ require 'pg_shrink/version'
 Gem::Specification.new do |spec|
   spec.name          = 'pg_shrink'
   spec.version       = PgShrink::VERSION
-  spec.authors       = ['Kevin Ball']
-  spec.email         = ['kmball11@gmail.com']
+  spec.authors       = ['Kevin Ball', 'Matt Nemenman']
+  spec.email         = ['kmball11@gmail.com', 'matt@apartmentlist.com']
   spec.description   = 'pg_shrink makes it simple to shrink and sanitize a PosrgreSQL database'
   spec.summary       = 'pg_shrink'
-  spec.homepage      = 'https://github.com/apartmentlist/pg-shrink'
+  spec.homepage      = 'https://github.com/apartmentlist/pg_shrink'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)

data/spec/pg_shrink/database/postgres_spec.rb

@@ -8,29 +8,36 @@ describe PgShrink::Database::Postgres do
 
   before(:all) do
     PgSpecHelper.reset_database
+
+    # id column created implicitly
     PgSpecHelper.create_table(db.connection, :test_table,
-                              {'name' => 'character(128)', 'test' => 'integer'})
+                              {'name' => 'character(128)', 'value' => 'integer'})
+
+    # id column created implicitly
+    PgSpecHelper.create_table(db.connection, :test_sub_table,
+                              {'test_table_id' => 'integer', 'value' => 'character(128)', })
   end
 
   before(:each) do
     PgSpecHelper.clear_table(db.connection, :test_table)
+    PgSpecHelper.clear_table(db.connection, :test_sub_table)
   end
 
-  context "A simple postgres database" do
-    it "sets up a Sequel connection" do
+  context 'A simple postgres database' do
+    it 'sets up a Sequel connection' do
       expect(db.connection.class).to eq(Sequel::Postgres::Database)
     end
 
-    context "with 20 simple records" do
+    context 'with 20 simple records' do
       before(:each) do
         (1..20).each do |i|
           db.connection.run(
-            "insert into test_table (name, test) values ('test', #{i})"
+            "insert into test_table (name, value) values ('test', #{i})"
           )
         end
       end
 
-      it "can fetch records in batches" do
+      it 'can fetch records in batches' do
         batch_sizes = []
         db.records_in_batches(:test_table) do |batch|
           batch_sizes << batch.size
@@ -38,29 +45,29 @@ describe PgShrink::Database::Postgres do
         expect(batch_sizes).to eq([5, 5, 5, 5])
       end
 
-      it "throws an error if records change their primary keys during update" do
-        old_records = db.connection["select * from test_table where test <= 5"].
+      it 'throws an error if records change their primary keys during update' do
+        old_records = db.connection['select * from test_table where value <= 5'].
           all
         new_records = old_records.map {|r| r.merge(:id => r[:id] * 10)}
         expect {db.update_records(:test_table, old_records, new_records)}.
           to raise_error
       end
 
-      it "can delete records based on a condition" do
-        db.delete_records(:test_table, {:test => 1..5})
+      it 'can delete records based on a condition' do
+        db.delete_records(:test_table, {:value => 1..5})
 
-        results = db.connection["select * from test_table"].all
+        results = db.connection['select * from test_table'].all
         expect(results.size).to eq(15)
-        expect(results.map {|r| r[:test]}).to match_array((6..20).to_a)
+        expect(results.map {|r| r[:value]}).to match_array((6..20).to_a)
       end
 
-      it "can update records" do
-        old_records = db.connection["select * from test_table where test <= 5"].
+      it 'can update records' do
+        old_records = db.connection['select * from test_table where value <= 5'].
           all
-        new_records = old_records.map {|r| r.merge(:test => r[:test] * 10)}
+        new_records = old_records.map {|r| r.merge(:value => r[:value] * 10)}
         db.update_records(:test_table, old_records, new_records)
         expect(
-          db.connection["select * from test_table where test <= 5"].all.size
+          db.connection['select * from test_table where value <= 5'].all.size
         ).to eq(0)
         updated_records = db.connection[:test_table].
           where(:id => old_records.map {|r| r[:id]}).all
@@ -68,41 +75,121 @@ describe PgShrink::Database::Postgres do
         expect(updated_records).to eq(new_records)
       end
 
-      it "throws an error if you try to delete records in update" do
-        old_records = db.connection["select * from test_table where test <= 5"].
+      it 'throws an error if you try to delete records in update' do
+        old_records = db.connection['select * from test_table where value <= 5'].
           all
         new_records = old_records.first(2)
         expect {db.update_records(:test_table, old_records, new_records)}.
           to raise_error
       end
 
-      it "deletes the whole table" do
+      it 'deletes the whole table' do
         db.remove_table(:test_table)
         db.filter!
-        expect(db.connection["select * from test_table"].all.size).to eq(0)
+        expect(db.connection['select * from test_table'].all.size).to eq(0)
       end
-      describe "on a table with no primary key" do
+
+
+      describe 'on a table with no primary key' do
+
         before(:all) do
           PgSpecHelper.create_table(db.connection, :no_primary_key,
                               {'name' => 'character(128)',
                                'test' => 'integer'}, nil)
         end
+
         before(:each) do
+          PgSpecHelper.clear_table(db.connection, :no_primary_key)
           (1..20).each do |i|
             db.connection.run(
-              "insert into no_primary_key (name, test) values ('test', #{i})"
-            )
-        end
-
+              "insert into no_primary_key (name, test) values ('test', #{i})")
+          end
         end
 
-        it "can still remove the whole table" do
+        it 'can still remove the whole table' do
           db.remove_table(:no_primary_key, :primary_key => false)
           db.filter!
-          expect(db.connection["select * from no_primary_key"].all.size).to eq(0)
+          expect(db.connection['select * from no_primary_key'].all.size).to eq(0)
 
-          end
+        end
+
+      end
+
+    end
+  end
+
+  context 'A table and subtable' do
+
+    before(:each) do
+      table_values = [
+        [1, 'john'],
+        [2, 'chris'],
+        [3, 'matt'],
+      ]
+
+      sub_table_values = [
+        [1, 'john_value_1'],
+        [1, 'john_value_2'],
+
+        [2, 'chris_value_1'],
+
+        [3, 'matt_value_1'],
+        [3, 'matt_value_2'],
+        [3, 'matt_value_3'],
+      ]
+
+      table_values.each do |row|
+        db.connection.run(
+          "insert into test_table (id, name, value) values (#{row[0]}, '#{row[1]}', #{row[0]})")
+      end
+
+      sub_table_values.each do |row|
+        db.connection.run(
+          "insert into test_sub_table (test_table_id, value) values (#{row[0]}, '#{row[1]}')")
+      end
+    end
+
+    context 'delete' do
+
+      before(:each) do
+        db.connection.run(
+          "delete from test_table where name = 'matt'"
+        )
+      end
+
+      it 'propagates to subtable' do
+
+        db.propagate_delete(
+          parent_table: 'test_table',
+          child_table: 'test_sub_table',
+          parent_key: 'id',
+          child_key: 'test_table_id')
+
+        expect(db.connection['select * from test_sub_table where test_table_id = 3'].all.size).to eq(0)
+      end
+
+      it 'propagates to subtable honoring where restriction' do
+        db.propagate_delete(
+          parent_table: 'test_table',
+          child_table: 'test_sub_table',
+          parent_key: 'id',
+          child_key: 'test_table_id',
+          where: "value = 'matt_value_2'")
+
+        expect(db.connection['select * from test_sub_table where test_table_id = 3'].all.size).to eq(2)
       end
+
+      it 'propagates to subtable (nil where ignored)' do
+        db.propagate_delete(
+          parent_table: 'test_table',
+          child_table: 'test_sub_table',
+          parent_key: 'id',
+          child_key: 'test_table_id',
+          where: nil)
+
+        expect(db.connection['select * from test_sub_table where test_table_id = 3'].all.size).to eq(0)
+      end
+
     end
   end
 end

data/spec/pg_shrink/table_spec.rb

@@ -45,14 +45,10 @@ describe PgShrink::Table do
     end
   end
 
-  context "when a subtable filter is specified" do
+  context "when any subtable filter is specified" do
     let(:database) {PgShrink::Database.new}
     let(:table) { PgShrink::Table.new(database, :test_table, :primary_key => false) }
 
-    before(:each) do
-      table.filter_subtable(:subtable)
-    end
-
     it "yields back a table so additional manipulations can be made" do
       table.filter_subtable(:subtable) do |f|
         expect(f.class).to eq(PgShrink::Table)
@@ -61,10 +57,12 @@ describe PgShrink::Table do
     end
 
     it "adds subtable_filter to subtable_filters array" do
+      table.filter_subtable(:subtable)
       expect(table.subtable_filters.size).to eq(1)
     end
   end
 
+
   context "when a remove is specified" do
     let(:database) {PgShrink::Database.new}
     let(:table) { PgShrink::Table.new(database, :test_table) }

data/spec/pg_shrink_spec.rb

@@ -14,13 +14,13 @@ describe PgShrink do
   end
 
 
-  it "should let you specify a different batch size" do
+  it 'should let you specify a different batch size' do
     opts = PgSpecHelper.pg_config.merge(:batch_size => 20000)
     db = PgShrink::Database::Postgres.new(opts)
     expect(db.batch_size).to eq(20000)
   end
 
-  describe "simple foreign_key setup" do
+  describe 'simple foreign_key setup' do
     before(:all) do
       # Rspec doesn't want you using 'let' defined things in before(:all)
       connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
@@ -35,9 +35,9 @@ describe PgShrink do
     end
 
 
-    describe "simple two table filtering" do
+    describe 'simple two table filtering' do
 
-      describe "with 20 users and associated preferences" do
+      describe 'with 20 users and associated preferences' do
         before(:each) do
           PgSpecHelper.clear_table(database.connection, :users)
           PgSpecHelper.clear_table(database.connection, :user_preferences)
@@ -53,24 +53,24 @@ describe PgShrink do
             end
           end
         end
-        describe "with a conditions string" do
+        describe 'with a conditions string' do
           before(:each) do
             database.filter_table(:users) do |f|
               f.filter_by("name like '%test 1%'")
             end
           end
 
-          it "Should not call records in batches" do
+          it 'Should not call records in batches' do
             expect(database).not_to receive(:records_in_batches)
             database.shrink!
           end
 
-          it "Should call delete_records once" do
+          it 'Should call delete_records once' do
             expect(database).to receive(:delete_records).once
             database.shrink!
           end
 
-          it "Should result in the appropriate records being deleted" do
+          it 'Should result in the appropriate records being deleted' do
             database.shrink!
             remaining_users = database.connection.from(:users).all
             # 1 and 10-19
@@ -78,7 +78,7 @@ describe PgShrink do
           end
         end
 
-        describe "when filtering just with a conditions hash" do
+        describe 'when filtering just with a conditions hash' do
           before(:each) do
             database.filter_table(:users) do |f|
               f.filter_by({
@@ -88,30 +88,30 @@ describe PgShrink do
             end
           end
 
-          it "Should not call records in batches" do
+          it 'Should not call records in batches' do
             expect(database).not_to receive(:records_in_batches)
             database.shrink!
           end
 
-          it "Should call delete_records once" do
+          it 'Should call delete_records once' do
             expect(database).to receive(:delete_records).once
             database.shrink!
           end
 
-          it "Should result in the appropriate records being deleted" do
+          it 'Should result in the appropriate records being deleted' do
             database.shrink!
             remaining_users = database.connection.from(:users).all
             expect(remaining_users.size).to eq(10)
           end
 
-          describe "with a subtable_filter" do
+          describe 'with a subtable_filter' do
             before(:each) do
               database.filter_table(:users) do |f|
                 f.filter_subtable(:user_preferences, :foreign_key => :user_id)
               end
             end
 
-            it "should remove the appropriate subtable records" do
+            it 'should remove the appropriate subtable records' do
               database.shrink!
               remaining_prefs = database.connection.from(:user_preferences).all
               expect(remaining_prefs.size).to eq(30)
@@ -119,11 +119,11 @@ describe PgShrink do
           end
         end
 
-        describe "with a test shrinkfile" do
+        describe 'with a test shrinkfile' do
           let(:shrinkfile) {"spec/Shrinkfile.basic"}
           let(:url) {database.connection_string}
 
-          it "should set up a postgres database" do
+          it 'should set up a postgres database' do
             expect(PgShrink::Database::Postgres).to receive(:new) do |opts|
                 expect(opts[:postgres_url]).to eq(database.connection_string)
               end.and_return(database)
@@ -132,7 +132,7 @@ describe PgShrink do
         end
 
 
-        describe "a simple filter and subtable" do
+        describe 'a simple filter and subtable' do
           before(:each) do
             database.filter_table(:users) do |f|
               f.filter_by "name = 'test 1'"
@@ -141,12 +141,12 @@ describe PgShrink do
             database.filter!
           end
 
-          it "will filter users down to the one matching" do
+          it 'will filter users down to the one matching' do
             remaining_users = database.connection.from(:users).all
             expect(remaining_users.size).to eq(1)
           end
 
-          it "will filter preferences to only those associated with the user" do
+          it 'will filter preferences to only those associated with the user' do
             remaining_user = database.connection.from(:users).first
             remaining_preferences = database.connection.
               from(:user_preferences).all
@@ -156,7 +156,7 @@ describe PgShrink do
           end
         end
 
-        describe "a simple filter and subtable with sanitization on each" do
+        describe 'a simple filter and subtable with sanitization on each' do
 
           before(:each) do
             database.filter_table(:users) do |f|
@@ -179,14 +179,14 @@ describe PgShrink do
             database.shrink!
           end
 
-          it "should result in 1 sanitized users" do
+          it 'should result in 1 sanitized users' do
             remaining_users = database.connection.from(:users).all
             expect(remaining_users.size).to  eq(1)
             expect(remaining_users.first[:name]).to match(/sanitized/)
             expect(remaining_users.first[:email]).to match(/blank_email/)
           end
 
-          it "should result in 3 sanitized preferences" do
+          it 'should result in 3 sanitized preferences' do
             remaining_user = database.connection.from(:users).first
             remaining_preferences = database.connection.
               from(:user_preferences).all
@@ -197,7 +197,7 @@ describe PgShrink do
           end
         end
       end
-      describe "with users and preferences including email as value" do
+      describe 'with users and preferences including email as value' do
         before(:each) do
           PgSpecHelper.clear_table(database.connection, :users)
           PgSpecHelper.clear_table(database.connection, :user_preferences)
@@ -216,7 +216,7 @@ describe PgShrink do
           end
         end
 
-        describe "sanitizing subtable" do
+        describe 'sanitizing subtable' do
           before(:each) do
             database.filter_table(:users) do |f|
               f.sanitize do |u|
@@ -227,19 +227,18 @@ describe PgShrink do
                                   :foreign_key => :user_id,
                                   :local_field => :email,
                                   :foreign_field => :value,
-                                  :type_key => :name,
-                                  :type => 'email')
+                                  :where => { :name => 'email' })
             end
             database.shrink!
           end
 
-          it "should sanitize user preference emails" do
+          it 'should sanitize user preference emails' do
             remaining_preferences = database.connection.
               from(:user_preferences).where(:name => 'email').all
             remaining_values = remaining_preferences.map {|p| p[:value]}
             expect(remaining_values.grep(/blank_email/).size).to eq(20)
           end
-          it "should not sanitize preferences with a different type" do
+          it 'should not sanitize preferences with a different type' do
             remaining_preferences = database.connection.
               from(:user_preferences).where(:name => 'name').all
             remaining_values = remaining_preferences.map {|p| p[:value]}
@@ -250,7 +249,7 @@ describe PgShrink do
     end
 
 
-    describe "three table filter chain" do
+    describe 'three table filter chain' do
       before(:all) do
         # Rspec doesn't want you using 'let' defined things in before(:all)
         connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
@@ -260,7 +259,7 @@ describe PgShrink do
                                    'character varying(256)'})
       end
 
-      describe "with 20 users and associated preferences" do
+      describe 'with 20 users and associated preferences' do
         before(:each) do
           PgSpecHelper.clear_table(database.connection, :users)
           PgSpecHelper.clear_table(database.connection, :user_preferences)
@@ -288,7 +287,7 @@ describe PgShrink do
           end
         end
 
-        describe "a simple filter and chained subtables" do
+        describe 'a simple filter and chained subtables' do
           before(:each) do
             database.filter_table(:users) do |f|
               f.filter_by "name = 'test 1'"
@@ -301,11 +300,11 @@ describe PgShrink do
 
             database.filter!
           end
-          it "filters users down to the one matching" do
+          it 'filters users down to the one matching' do
             remaining_users = database.connection.from(:users).all
             expect(remaining_users.size).to  eq(1)
           end
-          it "filters preferences to only those associated with the user" do
+          it 'filters preferences to only those associated with the user' do
             remaining_user = database.connection.from(:users).first
             remaining_preferences = database.connection.
                                              from(:user_preferences).all
@@ -313,8 +312,8 @@ describe PgShrink do
             expect(remaining_preferences.map {|u| u[:user_id]}.uniq).
               to eq([remaining_user[:id]])
           end
-          it "filters preference values to those associated with the " +
-             "preferences remaining" do
+          it 'filters preference values to those associated with the ' +
+             'preferences remaining' do
             remaining_user = database.connection.from(:users).first
             remaining_preferences = database.connection.
               from(:user_preferences).all
@@ -329,7 +328,7 @@ describe PgShrink do
       end
     end
   end
-  describe "polymorphic foreign key subtables" do
+  describe 'polymorphic foreign key subtables' do
     before(:all) do
       # Rspec doesn't want you using 'let' defined things in before(:all)
       connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
@@ -343,7 +342,7 @@ describe PgShrink do
                                  'name' => 'character varying(256)',
                                  'value' => 'character varying(256)'})
     end
-    describe "with 20 users, associated prefs, and prefs for different type" do
+    describe 'with 20 users, associated prefs, and prefs for different type' do
       before(:each) do
         PgSpecHelper.clear_table(database.connection, :users)
         PgSpecHelper.clear_table(database.connection, :preferences)
@@ -363,17 +362,17 @@ describe PgShrink do
         end
       end
 
-      describe "with condition filters" do
-        describe "simple cascade" do
+      describe 'with condition filters' do
+        describe 'simple cascade' do
           before(:each) do
             database.filter_table(:users) do |f|
-              f.filter_by(:name => "test 1")
-              f.filter_subtable(:preferences, :foreign_key => :context_id,
-                                :type_key => :context_type, :type => 'User')
+              f.filter_by(name: 'test 1')
+              f.filter_subtable(:preferences, foreign_key: :context_id,
+                                                    where: { context_type: 'User' } )
             end
             database.filter!
           end
-          it "will filter prefs with context_type 'User'" do
+          it 'will filter prefs with context_type User' do
             #
             remaining_user = database.connection.from(:users).first
             remaining_preferences = database.connection.from(:preferences).
@@ -383,13 +382,13 @@ describe PgShrink do
               to eq([remaining_user[:id]])
           end
 
-          it "will not filter preferences without context_type user" do
+          it 'will not filter preferences without context_type user' do
             remaining_preferences = database.connection.from(:preferences).
               where(:context_type => 'OtherClass').all
             expect(remaining_preferences.size).to eq(20)
           end
         end
-        describe "an extra layer of polymorphic subtables" do
+        describe 'an extra layer of polymorphic subtables' do
           before(:all) do
             connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
                          connection
@@ -416,20 +415,19 @@ describe PgShrink do
             end
 
             database.filter_table(:users) do |f|
-              f.filter_by(:name => "test 1")
-              f.filter_subtable(:preferences, :foreign_key => :context_id,
-                                :type_key => :context_type, :type => 'User')
+              f.filter_by(name: 'test 1')
+              f.filter_subtable(:preferences, foreign_key: :context_id,
+                                                    where: { context_type: 'User' } )
             end
 
             database.filter_table(:preferences) do |f|
               f.filter_subtable(:preference_dependents,
-                                :foreign_key => :context_id,
-                                :type_key => :context_type,
-                                :type => 'Preference')
+                                foreign_key: :context_id,
+                                      where: { context_type: 'Preference' })
             end
             database.filter!
           end
-          it "will filter preference dependents associated with preferences" do
+          it 'will filter preference dependents associated with preferences' do
             remaining_preferences = database.connection.from(:preferences).all
             remaining_dependents = database.connection.
               from(:preference_dependents).
@@ -438,7 +436,7 @@ describe PgShrink do
             expect(remaining_dependents.size).to eq(remaining_preferences.size)
           end
 
-          it "will not filter preference dependents with different type" do
+          it 'will not filter preference dependents with different type' do
             other_dependents = database.connection.
               from(:preference_dependents).
               where(:context_type => 'SomeOtherClass').all
@@ -447,17 +445,17 @@ describe PgShrink do
         end
       end
 
-      describe "simple two table filtering" do
+      describe 'simple two table filtering' do
         before(:each) do
           database.filter_table(:users) do |f|
             f.filter_by "name = 'test 1'"
-            f.filter_subtable(:preferences, :foreign_key => :context_id,
-                              :type_key => :context_type, :type => 'User')
+            f.filter_subtable(:preferences, foreign_key: :context_id,
+                                                  where: {context_type: 'User'})
           end
           database.filter!
         end
 
-        it "will filter prefs with context_type 'User'" do
+        it 'will filter prefs with context_type User' do
           remaining_user = database.connection.from(:users).first
           remaining_preferences = database.connection.from(:preferences).
             where(:context_type => 'User').all
@@ -466,14 +464,14 @@ describe PgShrink do
             to eq([remaining_user[:id]])
         end
 
-        it "will not filter preferences without context_type user" do
+        it 'will not filter preferences without context_type user' do
           remaining_preferences = database.connection.from(:preferences).
             where(:context_type => 'OtherClass').all
           expect(remaining_preferences.size).to eq(20)
         end
       end
 
-      describe "an extra layer of polymorphic subtables" do
+      describe 'an extra layer of polymorphic subtables' do
         before(:all) do
           connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
                        connection
@@ -501,20 +499,19 @@ describe PgShrink do
 
           database.filter_table(:users) do |f|
             f.filter_by "name = 'test 1'"
-            f.filter_subtable(:preferences, :foreign_key => :context_id,
-                              :type_key => :context_type, :type => 'User')
+            f.filter_subtable(:preferences, foreign_key: :context_id,
+                                                  where: {context_type: 'User'} )
           end
 
           database.filter_table(:preferences) do |f|
             f.filter_subtable(:preference_dependents,
-                              :foreign_key => :context_id,
-                              :type_key => :context_type,
-                              :type => 'Preference')
+                              foreign_key: :context_id,
+                                    where: {context_type: 'Preference'} )
           end
           database.filter!
         end
 
-        it "will filter preference dependents associated with preferences" do
+        it 'will filter preference dependents associated with preferences' do
           remaining_preferences = database.connection.from(:preferences).all
           remaining_dependents = database.connection.
             from(:preference_dependents).
@@ -523,7 +520,7 @@ describe PgShrink do
           expect(remaining_dependents.size).to eq(remaining_preferences.size)
         end
 
-        it "will not filter preference dependents with different type" do
+        it 'will not filter preference dependents with different type' do
           other_dependents = database.connection.
             from(:preference_dependents).
             where(:context_type => 'SomeOtherClass').all
@@ -532,7 +529,7 @@ describe PgShrink do
       end
     end
   end
-  describe "has_and_belongs_to_many join tables" do
+  describe 'has_and_belongs_to_many join tables' do
     before(:all) do
       # Rspec doesn't want you using 'let' defined things in before(;all)
       connection = PgShrink::Database::Postgres.new(PgSpecHelper.pg_config).
@@ -547,7 +544,7 @@ describe PgShrink do
                                 {'name' => 'character varying(256)'})
     end
 
-    describe "with 5 users, each with 2 apartments, and 1 apartment shared by all 5" do
+    describe 'with 5 users, each with 2 apartments, and 1 apartment shared by all 5' do
       before(:each) do
         PgSpecHelper.clear_table(database.connection, :users)
         PgSpecHelper.clear_table(database.connection, :apartments_users)
@@ -572,7 +569,7 @@ describe PgShrink do
           end
         end
       end
-      describe "With a simple cascading filter" do
+      describe 'With a simple cascading filter' do
         before(:each) do
           database.filter_table(:users) do |f|
             f.filter_by "name = 'test 1'"
@@ -586,13 +583,13 @@ describe PgShrink do
           database.shrink!
         end
 
-        it "Should filter down apartments_users" do
+        it 'Should filter down apartments_users' do
           u = database.connection.from(:users).where(:name => "test 1").first
           remaining_join_table = database.connection.from(:apartments_users).all
           expect(remaining_join_table.size).to eq(3)
         end
 
-        it "Should filter apartments as well" do
+        it 'Should filter apartments as well' do
           remaining_join_table = database.connection.from(:apartments_users).all
           remaining_apartments = database.connection.from(:apartments).all
           expect(remaining_apartments.size).to eq(3)

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: pg_shrink
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Kevin Ball
+- Matt Nemenman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-27 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -195,6 +196,7 @@ dependencies:
 description: pg_shrink makes it simple to shrink and sanitize a PosrgreSQL database
 email:
 - kmball11@gmail.com
+- matt@apartmentlist.com
 executables:
 - pg_shrink
 extensions: []
@@ -229,7 +231,7 @@ files:
 - spec/pg_shrink_spec.rb
 - spec/pg_spec_helper.rb
 - spec/spec_helper.rb
-homepage: https://github.com/apartmentlist/pg-shrink
+homepage: https://github.com/apartmentlist/pg_shrink
 licenses:
 - MIT
 metadata: {}