partial_ks 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c44b4f31d3904ec2fa73af0a8b4c1ef4194f416
-  data.tar.gz: d4e1e4117d37b38c02ab1ec3f8704074564e5606
+  metadata.gz: 073f6737128fd06c8791fb210f72d3a657a459de
+  data.tar.gz: 4ea3290c59333b803b506ad70d7f81480513737d
 SHA512:
-  metadata.gz: 0c0ab0cfe27acd0a8ea5c6fcc8d5eb28e48c3b0cccc66c63d990c0c5528d697ef8c2ad29a0865c86ac6c7e6adb1a23642c545c570188b6cf5e449cd62b873f67
-  data.tar.gz: 13bb499ff85fbe75a4d60a83790bca00433d1d91441e29915152063340b9bf92fb8aafed499f8ab0e671935e64ff57a91e158acd4cb93215a31d0551eb19c21a
+  metadata.gz: 99dcd5e6f8a03017b98ef20099683108fd9173962865324bcb3166fc80bbf07ff5c36e7c5668ea138558c22a61a0278489570b5f5454bb1c461578f6c48ac7d0
+  data.tar.gz: 4f29d6e17164c9d25ff214c210b4ca5355560c898e3d3230ff59aa086f9d444eb9529c8422236179784439004db0eea55ca02ab9502f63804f5680986cc215cc

data/CHANGES.md

@@ -1,5 +1,28 @@
 # Changelog
 
+# 0.2.0
+
+* Support filtering via a has_many association
+
+You can now skip manually specifying the resultant filter on a has_many "parent". So previously:
+
+```
+[
+  [User, Tags, User.where(:id => Tags.pluck(:id))]
+]
+```
+
+can now just be :
+
+```
+[
+  [User, Tags]
+]
+```
+
+* Can now specify a full SQL statement in the manual specification
+
+
 # 0.1.1
 
 Fix minor regression with Runner#report

data/README.md

@@ -1,17 +1,19 @@
-PartialKs
-  - ConfigurationGenerator
-  - Runner
-    - runs
-    - reports (mostly for debugging)
+# PartialKs
+
+A library to use kitchen-sync to sync a subset of your database
+
+# Usage
 
 So how does it work ?
 
-`brew install kitchen-sync`
 
 ```
 manual_configuration = []
 config = PartialKs::ConfigurationGenerator.new(manual_configuration).call
-PartialKs::Runner.new([config]).run!
+PartialKs::Runner.new([config]).run! do |tables_to_filter, tables|
+  puts tables_to_filter.inspect
+  puts tables.inspect
+end
 ```
 
 You can specify manual configurations if needed.
@@ -23,11 +25,26 @@ manual_configuration = [
 ]
 ```
 
-TODO :
+NB: The first use case for this gem is to be run in conjuction with [Kitchen Sync](https://github.com/willbryant/kitchen_sync). On OSX, one can install Kitchen Sync using `brew install kitchen-sync`
+
+*TODO*
+
+* Provide a way for users to pass in manual configurations
+* Tool to run report using bundle exec
+
+# Public API
+
+It currently consists of :
+
+  - ConfigurationGenerator
+  - Runner
+    - runs
+    - reports (mostly for debugging)
+
+*TODO*
 
 * Rename PartialKs::ConfigurationGenerator#call to something better
 * Minimize Public API
-* Tool to run report using bundle exec
 
 # Not supported
 

data/lib/partial_ks/filtered_table.rb

@@ -1,32 +1,39 @@
-class PartialKs::FilteredTable
-  attr_reader :table, :parent_model, :custom_filter_relation
-  delegate :table_name, :to => :table
+module PartialKs
+  class FilteredTable
+    attr_reader :table, :parent_model, :custom_filter_relation
+    delegate :table_name, :to => :table
 
-  def initialize(table, parent_model, custom_filter_relation: nil)
-    @table = table
-    @parent_model = parent_model
-    @custom_filter_relation = custom_filter_relation
-  end
-
-  def kitchen_sync_filter
-    filter_condition = custom_filter_relation || parent_model
+    def initialize(table, parent_model, custom_filter_relation: nil)
+      @table = table
+      @parent_model = parent_model
+      @custom_filter_relation = custom_filter_relation
+    end
 
-    if !filter_condition.nil?
-      if filter_condition.is_a?(ActiveRecord::Relation) || filter_condition.respond_to?(:where_sql)
-        only_filter = filter_condition.where_sql.to_s.sub("WHERE", "")
-      elsif filter_condition.is_a?(String)
-        only_filter = filter_condition
+    def kitchen_sync_filter
+      if custom_filter_relation
+        {"only" => filter_based_on_custom_filter_relation}
+      elsif parent_model
+        {"only" => filter_based_on_parent_model}
       else
-        # this only supports parents where it's a belongs_to
-        # TODO we can make it work with has_many
-        # e.g. SomeModel.reflect_on_association(:elses)
-        association = table.model.reflect_on_all_associations(:belongs_to).find {|assoc| assoc.class_name == filter_condition.name}
-        raise "#{filter_condition.name} not found in #{table.model.name} associations" if association.nil?
+        nil
+      end
+    end
+
+    protected
+    def filter_based_on_parent_model
+      table.relation_for_associated_model(parent_model).where_sql.to_s.sub(where_regexp, "")
+    end
 
-        only_filter = "#{association.foreign_key} IN (#{[0, *filter_condition.pluck(:id)].join(',')})"
+    def filter_based_on_custom_filter_relation
+      if custom_filter_relation.is_a?(ActiveRecord::Relation) || custom_filter_relation.respond_to?(:where_sql)
+        only_filter = custom_filter_relation.where_sql.to_s.sub(where_regexp, "")
+      elsif custom_filter_relation.is_a?(String)
+        only_filter = custom_filter_relation.sub(where_regexp, "")
       end
+    end
 
-      {"only" => only_filter}
+    def where_regexp
+      /\A.*WHERE\s*/i
     end
   end
 end

data/lib/partial_ks/parent_inferrer.rb

@@ -1,19 +1,21 @@
-class PartialKs::ParentInferrer
-  CannotInfer = Class.new(StandardError)
+module PartialKs
+  class ParentInferrer
+    CannotInfer = Class.new(StandardError)
 
-  attr_reader :table
+    attr_reader :table
 
-  def initialize(table)
-    @table = table
-  end
+    def initialize(table)
+      @table = table
+    end
 
-  def inferred_parent_class
-    if table.top_level_table?
-      nil
-    elsif table.candidate_parent_classes.size == 1
-      table.candidate_parent_classes.first
-    else
-      raise CannotInfer, "table has multiple candidates for parents"
+    def inferred_parent_class
+      if table.top_level_table?
+        nil
+      elsif table.candidate_parent_classes.size == 1
+        table.candidate_parent_classes.first
+      else
+        raise CannotInfer, "table has multiple candidates for parents"
+      end
     end
   end
 end

data/lib/partial_ks/runner.rb

@@ -1,73 +1,75 @@
-class PartialKs::Runner
-  attr_reader :table_graphs
+module PartialKs
+  class Runner
+    attr_reader :table_graphs
 
-  def initialize(table_graphs)
-    @table_graphs = table_graphs
-  end
+    def initialize(table_graphs)
+      @table_graphs = table_graphs
+    end
 
-  def run!
-    each_generation do |generation|
-      tables_to_filter = {}
-      table_names = []
+    def run!
+      each_generation do |generation|
+        tables_to_filter = {}
+        table_names = []
 
-      generation.each do |table|
-        table_names << table.table_name
-        filter_config = table.kitchen_sync_filter
+        generation.each do |table|
+          table_names << table.table_name
+          filter_config = table.kitchen_sync_filter
 
-        if !filter_config.nil?
-          tables_to_filter[table.table_name] = filter_config
+          if !filter_config.nil?
+            tables_to_filter[table.table_name] = filter_config
+          end
         end
-      end
 
-      # TODO output only tables_to_filter, depending on how KS handles filters
-      yield tables_to_filter, table_names
+        # TODO output only tables_to_filter, depending on how KS handles filters
+        yield tables_to_filter, table_names
+      end
     end
-  end
 
-  def report
-    result = []
-    each_generation.with_index do |generation, depth|
-      generation.each do |table|
-        result << [table.table_name, table.parent_model, table.custom_filter_relation, depth]
+    def report
+      result = []
+      each_generation.with_index do |generation, depth|
+        generation.each do |table|
+          result << [table.table_name, table.parent_model, table.custom_filter_relation, depth]
+        end
       end
+      result
     end
-    result
-  end
 
-  def each_generation
-    return enum_for(:each_generation) unless block_given?
+    def each_generation
+      return enum_for(:each_generation) unless block_given?
 
-    generations.each do |generation|
-      yield generation
+      generations.each do |generation|
+        yield generation
+      end
     end
-  end
 
-  protected
-  def generations
-    return @generations if defined?(@generations)
+    protected
+    def generations
+      return @generations if defined?(@generations)
 
-    @generations = []
-    table_graphs.each do |table_graph|
-      q = []
+      @generations = []
+      table_graphs.each do |filtered_tables|
+        q = []
 
-      table_graph.each do |table|
-        q << table if table.parent_model.nil?
-      end
+        filtered_tables.each do |filtered_table|
+          q << filtered_table if filtered_table.parent_model.nil?
+        end
 
-      until q.empty?
-        @generations << q
+        until q.empty?
+          @generations << q
 
-        next_generation = []
-        q.each do |table|
-          table_graph.each do |child_table|
-            next_generation << child_table if child_table.parent_model && child_table.parent_model.table_name == table.table_name
+          next_generation = []
+          q.each do |table|
+            filtered_tables.each do |child_table|
+              next_generation << child_table if child_table.parent_model && child_table.parent_model.table_name == table.table_name
+            end
           end
-        end
 
-        q = next_generation
+          q = next_generation
+        end
       end
-    end
 
-    @generations
+      @generations
+    end
   end
 end

data/lib/partial_ks/table.rb

@@ -27,6 +27,20 @@ module PartialKs
       belongs_to_reflections.map(&:table_name)
     end
 
+    def relation_for_associated_model(klass)
+      association = model.reflect_on_all_associations.find {|assoc| assoc.class_name == klass.name}
+      raise "#{filter_condition.name} not found in #{model.name} associations" if association.nil?
+
+      case association.macro
+      when :belongs_to
+        model.where(association.foreign_key => [0, *klass.pluck(:id)])
+      when :has_many
+        model.where(model.primary_key => [0, *klass.pluck(association.foreign_key)])
+      else
+        raise "Unknown macro"
+      end
+    end
+
     private
     def belongs_to_reflections
       @belongs_to_reflections ||= model.reflect_on_all_associations(:belongs_to)

data/lib/partial_ks/version.rb

@@ -1,3 +1,3 @@
 module PartialKs
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/partial_ks.rb

@@ -1,8 +1,5 @@
 require 'active_record'
 
-module PartialKs
-end
-
 require_relative 'partial_ks/all_rails_models'
 require_relative 'partial_ks/filtered_table'
 require_relative 'partial_ks/parent_inferrer'

data/test/filtered_table_test.rb

@@ -2,17 +2,36 @@ require 'test_helper'
 
 describe "kitchen sync filter" do
   let(:table) { PartialKs::Table.new(PostTag) }
+  let(:parent) { Minitest::Mock.new }
+
+  it "proxies to Table if there's parent only" do
+    table_parent_relation_method = :relation_for_associated_model
+    relation_mock = Minitest::Mock.new
+    relation_mock.expect :where_sql, "WHERE tag_id IN (0)"
 
-  it "uses parent as the filter" do
-    parent = Tag
     filtered_table = PartialKs::FilteredTable.new(table, parent)
-    filtered_table.kitchen_sync_filter.must_equal({"only" => 'tag_id IN (0)'})
+    table.stub table_parent_relation_method, relation_mock do
+      filtered_table.kitchen_sync_filter.must_equal({"only" => 'tag_id IN (0)'})
+    end
   end
 
   it "uses the custom filter if provided" do
     filter = PostTag.where(:id => [1, 2])
     filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: filter)
-    filtered_table.kitchen_sync_filter.must_equal({"only" => ' "post_tags"."id" IN (1, 2)'})
+    filtered_table.kitchen_sync_filter.must_equal({"only" => '"post_tags"."id" IN (1, 2)'})
+  end
+
+  it "uses a SQL where fragment as a filter if provided" do
+    string_filter = "1=0"
+    filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: string_filter)
+    filtered_table.kitchen_sync_filter.must_equal({"only" => string_filter})
+  end
+
+  it "uses a SQL statement as a filter if provided" do
+    string_filter = "1=0"
+    sql_statement = "select * from #{table.table_name} where #{string_filter}"
+    filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: sql_statement)
+    filtered_table.kitchen_sync_filter.must_equal({"only" => string_filter})
   end
 
   it "returns nil if parent is nil" do
@@ -20,12 +39,4 @@ describe "kitchen sync filter" do
     filtered_table.kitchen_sync_filter.must_be_nil
   end
 
-  describe "table with different :foreign_key" do
-    let(:table) { PartialKs::Table.new(OldTag) }
-
-    it "uses the foreign key that's present in the table" do
-      filtered_table = PartialKs::FilteredTable.new(table, OldEntry)
-      filtered_table.kitchen_sync_filter.must_equal({"only" => 'blog_post_id IN (0)'})
-    end
-  end
 end

data/test/setup_models.rb

@@ -1,11 +1,14 @@
 class User < ActiveRecord::Base
+  has_many :blog_posts
 end
 
 class BlogPost < ActiveRecord::Base
   belongs_to :user
+  has_many :post_tags
 end
 
 class Tag < ActiveRecord::Base
+  has_many :post_tags
 end
 
 class PostTag < ActiveRecord::Base

data/test/table_test.rb

@@ -15,4 +15,39 @@ describe PartialKs::Table do
       table.candidate_parent_classes.must_equal []
     end
   end
+
+  describe "relation for association" do
+    let(:table) { PartialKs::Table.new(BlogPost) }
+
+    it "emits the correct foreign key for the table for belongs_to" do
+      table.relation_for_associated_model(User).must_equal BlogPost.where(:user_id => 0)
+    end
+
+    it "use results from pluck for belongs_to" do
+      user_ids = [1,2,3]
+      User.stub :pluck, user_ids do
+        table.relation_for_associated_model(User).must_equal BlogPost.where(:user_id => [0] + user_ids)
+      end
+    end
+
+    it "emits the id condition for has_many" do
+      table.relation_for_associated_model(PostTag).must_equal BlogPost.where(:id => 0)
+    end
+
+    it "uses results from pluck for has_many" do
+      id = 111
+
+      PostTag.stub :pluck, [id] do
+        table.relation_for_associated_model(PostTag).must_equal BlogPost.where(:id => [0] + [id])
+      end
+    end
+
+    describe "table with non-conventional :foreign_key" do
+      let(:table) { PartialKs::Table.new(OldTag) }
+
+      it "uses the foreign key that's present in the table" do
+        table.relation_for_associated_model(OldEntry).must_equal OldTag.where(:blog_post_id => 0)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: partial_ks
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Thong Kuah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-12 00:00:00.000000000 Z
+date: 2017-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord