partial_ks 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68505ca861cdb0855c62be32cd6b9377f5c6f687
-  data.tar.gz: 1dabcb9334a38d27ccbf823237a031aadc4c8b26
+  metadata.gz: a6cd50565fe47324715461ded8eb3123a717f1f8
+  data.tar.gz: 2c5c3a0ab04b6a056b29760bc4b4a8aa1a061a24
 SHA512:
-  metadata.gz: fcb48cf2bdcc7151bb99b69a684798185ff6344cc7c7f77fd4316642d0b8ff0eb93f3e00a1f3d41c47f02334473f3b11d9c1a842a32abe976e5cd46e0a6b54e7
-  data.tar.gz: 9e50c50f69aab5dff5a040943406d90e35241baa3adf0cef32ea8ce5abbb685a65839d236c9566cddcce5ab86408cb6227402c9bd04c4aa1c8c947c73e39fdc6
+  metadata.gz: b9e40d3d927f2b87ddb13831701eabb48d0fa8d9842fc1a47fcd7d4b87fe20f8244a16c3cff410303c5ce651f8e3e85334873f85eecf524df911a6c96d6e2989
+  data.tar.gz: 0108a674dc8eb3c0ab3bba60c11b8f9601d7e64e553b1f2a00e72c48594eeae04c8b30c27de663cc1ed2d0f6fab3fb0ba67090273ea476f12f51041fee012980

data/CHANGES.md

@@ -1,5 +1,26 @@
 # Changelog
 
+# 0.1.0
+
+* Switch to using Rails models rather than table names.
+
+You must now specify rails models in your manual_configuration.
+
+Remember, if you want to configure all models, you must eager load in development.
+
+```
+  Rails.application.eager_load!
+  Rails::Engine.subclasses.map(&:eager_load!)
+```
+
+* Reject polymorphic relationships from ever being a candidate parent.
+
+This has the implication that a table that wasn't considered top level could be
+top level.
+
+* Bugfix: Emit valid where SQL fragments for models which has a assocation with `:foreign_key`
+that does not follow convention
+
 ## 0.0.6
 
 Allow manual_configuration to transition to using model names (moving off from table names)

data/README.md

@@ -18,15 +18,22 @@ You can specify manual configurations if needed.
 
 ```
 manual_configuration = [
-  ["users", nil, User.where(:id => [1])],      # specify a subset of users. as users have no parent, specify `nil`
-  ["blog_posts", User]                         # filter blog_posts by User
+  [User, nil, User.where(:id => [1])],     # specify a subset of users. as users have no parent, specify `nil`
+  [BlogPost, User]                         # filter blog_posts by User
 ]
 ```
 
 TODO :
 
 * Rename PartialKs::ConfigurationGenerator#call to something better
-* What in the world is the tuples in `manual_configuration` meant to be ?
 * Minimize Public API
+* Tool to run report using bundle exec
+
+# Not supported
+
+Things that are not supported in this version.
+
+* Polymorphic relationships
+* Tables with STI
 
 

data/lib/partial_ks/all_rails_models.rb

@@ -0,0 +1,9 @@
+module PartialKs
+  def self.all_rails_models
+    if defined?(Rails)
+      ::Rails.application.eager_load!
+      ::Rails::Engine.subclasses.map(&:eager_load!)
+    end
+    ActiveRecord::Base.direct_descendants
+  end
+end

data/lib/partial_ks/configuration_generator.rb

@@ -3,11 +3,11 @@
 # and attempts to automatically populate the table into the table graph
 module PartialKs
   class ConfigurationGenerator
-    attr_reader :manual_configuration, :table_names
+    attr_reader :manual_configuration, :models
 
-    def initialize(manual_configuration, table_names: nil)
+    def initialize(manual_configuration, models: nil)
       @manual_configuration = manual_configuration
-      @table_names = table_names || ActiveRecord::Base.connection.tables
+      @models = models || PartialKs.all_rails_models
     end
 
     def call
@@ -16,14 +16,14 @@ module PartialKs
 
     protected
     def all_tables
-      @all_tables ||= @table_names.map {|table_name| PartialKs::Table.new(table_name) }.select(&:model?).index_by(&:table_name)
+      @all_tables ||= models.map {|model| PartialKs::Table.new(model) }.select(&:model?).index_by(&:table_name)
     end
 
     def filtered_tables
       synced_tables = {}
 
-      manual_configuration.each do |table_name_or_model, specified_parent_model, filter_for_table|
-        table_name = table_name_or_model.is_a?(String) ? table_name_or_model : table_name_or_model.table_name
+      manual_configuration.each do |model, specified_parent_model, filter_for_table|
+        table_name = model.table_name
         next unless all_tables[table_name]
 
         parent_model = specified_parent_model
@@ -35,8 +35,7 @@ module PartialKs
 
         begin
           inferrer = PartialKs::ParentInferrer.new(table)
-          #TODO get rid of try!
-          parent_model = all_tables[inferrer.inferred_parent_table].try!(:model)
+          parent_model = inferrer.inferred_parent_class
           synced_tables[table_name] = PartialKs::FilteredTable.new(table, parent_model)
         rescue PartialKs::ParentInferrer::CannotInfer
           next

data/lib/partial_ks/filtered_table.rb

@@ -8,7 +8,25 @@ class PartialKs::FilteredTable
     @custom_filter_relation = custom_filter_relation
   end
 
-  def filter_condition
-    custom_filter_relation || parent_model
+  def kitchen_sync_filter
+    filter_condition = custom_filter_relation || parent_model
+
+    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
+      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?
+
+        only_filter = "#{association.foreign_key} IN (#{[0, *filter_condition.pluck(:id)].join(',')})"
+      end
+
+      {"only" => only_filter}
+    end
   end
 end

data/lib/partial_ks/parent_inferrer.rb

@@ -7,11 +7,11 @@ class PartialKs::ParentInferrer
     @table = table
   end
 
-  def inferred_parent_table
+  def inferred_parent_class
     if table.top_level_table?
       nil
-    elsif table.non_nullable_parent_tables.size == 1
-      table.non_nullable_parent_tables.first
+    elsif table.candidate_parent_classes.size == 1
+      table.candidate_parent_classes.first
     else
       raise CannotInfer, "table has multiple candidates for parents"
     end

data/lib/partial_ks/runner.rb

@@ -12,18 +12,10 @@ class PartialKs::Runner
 
       generation.each do |table|
         table_names << table.table_name
-        filter_config = table.filter_condition
+        filter_config = table.kitchen_sync_filter
 
         if !filter_config.nil?
-          if filter_config.is_a?(ActiveRecord::Relation) || filter_config.respond_to?(:where_sql)
-            only_filter = filter_config.where_sql.to_s.sub("WHERE", "")
-          elsif filter_config.is_a?(String)
-            only_filter = filter_config
-          else
-            only_filter = "#{filter_config.to_s.foreign_key} IN (#{[0, *filter_config.pluck(:id)].join(',')})"
-          end
-
-          tables_to_filter[table.table_name] = {"only" => only_filter}
+          tables_to_filter[table.table_name] = filter_config
         end
       end
 
@@ -36,7 +28,7 @@ class PartialKs::Runner
     result = []
     each_generation.with_index do |generation, depth|
       generation.each do |table|
-        result << [table.table_name, table.parent_model, table.filter_condition, depth]
+        result << [table.table_name, table.parent_model, table.parent_model || table.custom_filter_relation, depth]
       end
     end
     result

data/lib/partial_ks/table.rb

@@ -1,15 +1,10 @@
 module PartialKs
   class Table
-    attr_reader :table_name
+    attr_reader :model
+    delegate :table_name, :to => :model
 
-    def initialize(table_name)
-      @table_name = table_name
-    end
-
-    def model
-      @model ||= table_name.classify.constantize
-    rescue NameError
-      nil
+    def initialize(model)
+      @model = model
     end
 
     # sometimes the table is present, but the model is not defined
@@ -19,15 +14,17 @@ module PartialKs
     end
 
     def top_level_table?
-      non_nullable_reflections.empty?
+      candidate_parent_classes.empty?
     end
 
-    def non_nullable_parent_tables
-      non_nullable_reflections.map(&:plural_name)
+    # NB: can't do polymorphic for now, rails errors on reflection#klass
+    # see, e.g. https://github.com/rails/rails/issues/15833
+    def candidate_parent_classes
+      non_nullable_reflections.reject(&:polymorphic?).map(&:klass)
     end
 
     def parent_tables
-      belongs_to_reflections.map(&:plural_name)
+      belongs_to_reflections.map(&:table_name)
     end
 
     private

data/lib/partial_ks/version.rb

@@ -1,3 +1,3 @@
 module PartialKs
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end

data/lib/partial_ks.rb

@@ -3,6 +3,7 @@ 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'
 require_relative 'partial_ks/runner'

data/partial_ks.gemspec

@@ -1,6 +1,6 @@
 require File.expand_path('../lib/partial_ks/version', __FILE__)
 
-spec = Gem::Specification.new do |gem|
+Gem::Specification.new do |gem|
   gem.name         = 'partial_ks'
   gem.version      = PartialKs::VERSION
   gem.summary      = "Partial KS"

data/test/configuration_generator_test.rb

@@ -1,9 +1,5 @@
 require 'test_helper'
 
-def pks_tables(*args)
-  args
-end
-
 def generator(manual, tables)
   PartialKs::ConfigurationGenerator.new(manual, tables).call.
     map {|f| [f.table_name, f.parent_model, f.custom_filter_relation] }
@@ -12,12 +8,12 @@ end
 describe "generating dependencies" do
   let(:manual_configuration) do
     [
-      ["users", nil, User.where(:id => [1])],
+      [User, nil, User.where(:id => [1])],
     ]
   end
 
   it "auto infers single belongs-to dependencies" do
-    generator(manual_configuration, table_names: pks_tables("users", "blog_posts")).
+    generator(manual_configuration, models: [User, BlogPost]).
       must_equal [
       ["users", nil, User.where(:id => [1])],
       ["blog_posts", User, nil]
@@ -25,34 +21,21 @@ describe "generating dependencies" do
   end
 
   it "auto infers top level tables" do
-    generator(manual_configuration, table_names: pks_tables("users", "tags")).
+    generator(manual_configuration, models: [User, Tag]).
       must_equal [
       ["users", nil, User.where(:id => [1])],
       ["tags", nil, nil]
     ]
   end
-end
 
-describe "transition to model based dependencies" do
-  let(:manual_configuration) do
-    [
-      [User, nil, User.where(:id => [1])],
-    ]
-  end
+  it "can infer models with different table_name" do
+    model = OldEntry
+    model.table_name.wont_equal model.name.tableize
 
-  it "auto infers single belongs-to dependencies" do
-    generator(manual_configuration, table_names: pks_tables("users", "blog_posts")).
+    generator(manual_configuration, models: [User, model]).
       must_equal [
       ["users", nil, User.where(:id => [1])],
-      ["blog_posts", User, nil]
-    ]
-  end
-
-  it "auto infers top level tables" do
-    generator(manual_configuration, table_names: pks_tables("users", "tags")).
-      must_equal [
-      ["users", nil, User.where(:id => [1])],
-      ["tags", nil, nil]
+      ["cms_table", nil, nil]
     ]
   end
 end

data/test/filtered_table_test.rb

@@ -1,22 +1,31 @@
 require 'test_helper'
 
-describe "filter condition" do
-  let(:table) { PartialKs::Table.new("users") }
+describe "kitchen sync filter" do
+  let(:table) { PartialKs::Table.new(PostTag) }
 
   it "uses parent as the filter" do
     parent = Tag
     filtered_table = PartialKs::FilteredTable.new(table, parent)
-    filtered_table.filter_condition.must_equal parent
+    filtered_table.kitchen_sync_filter.must_equal({"only" => 'tag_id IN (0)'})
   end
 
   it "uses the custom filter if provided" do
-    filter = User.where(:id => 1)
+    filter = PostTag.where(:id => [1, 2])
     filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: filter)
-    filtered_table.filter_condition.must_equal filter
+    filtered_table.kitchen_sync_filter.must_equal({"only" => ' "post_tags"."id" IN (1, 2)'})
   end
 
   it "returns nil if parent is nil" do
     filtered_table = PartialKs::FilteredTable.new(table, nil)
-    filtered_table.filter_condition.must_be_nil
+    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/parent_inferrer_test.rb

@@ -2,17 +2,17 @@ require 'test_helper'
 
 describe "inferring parents" do
   it "infers no parent for a top level table" do
-    table = PartialKs::Table.new("tags")
-    PartialKs::ParentInferrer.new(table).inferred_parent_table.must_equal nil
+    table = PartialKs::Table.new(Tag)
+    PartialKs::ParentInferrer.new(table).inferred_parent_class.must_be_nil
   end
 
   it "infers a parent for a table that has a single belongs_to" do
-    table = PartialKs::Table.new("blog_posts")
-    PartialKs::ParentInferrer.new(table).inferred_parent_table.must_equal "users"
+    table = PartialKs::Table.new(BlogPost)
+    PartialKs::ParentInferrer.new(table).inferred_parent_class.must_equal User
   end
 
   it "infers no parent for a table has multiple belongs_to" do
-    table = PartialKs::Table.new("post_tags")
-    lambda { PartialKs::ParentInferrer.new(table).inferred_parent_table }.must_raise PartialKs::ParentInferrer::CannotInfer
+    table = PartialKs::Table.new(PostTag)
+    lambda { PartialKs::ParentInferrer.new(table).inferred_parent_class }.must_raise PartialKs::ParentInferrer::CannotInfer
   end
 end

data/test/runner_test.rb

@@ -18,9 +18,9 @@ describe 'running based on output from generator' do
 
   let(:generator_output) do
     [
-      PartialKs::FilteredTable.new(PartialKs::Table.new("users"), nil, custom_filter_relation: User.where(:id => [1])),
-      PartialKs::FilteredTable.new(PartialKs::Table.new("tags"), nil),
-      PartialKs::FilteredTable.new(PartialKs::Table.new("blog_posts"), User),
+      PartialKs::FilteredTable.new(PartialKs::Table.new(User), nil, custom_filter_relation: User.where(:id => [1])),
+      PartialKs::FilteredTable.new(PartialKs::Table.new(Tag), nil),
+      PartialKs::FilteredTable.new(PartialKs::Table.new(BlogPost), User),
     ]
   end
 
@@ -45,7 +45,7 @@ describe 'running based on output from generator' do
   end
 
   it "yields all non-null filters" do
-    expected_filters     = generator_output.each_with_object({}) {|ft, hash| hash[ft.table_name] = ft.filter_condition if ft.filter_condition}
+    expected_filters     = generator_output.each_with_object({}) {|ft, hash| hash[ft.table_name] = ft.kitchen_sync_filter if ft.kitchen_sync_filter}
     actual_filters       = {}
 
     runner.run! do |tables_to_filter, table_names|
@@ -55,7 +55,7 @@ describe 'running based on output from generator' do
     actual_filters.size.must_equal expected_filters.size
     actual_filters.keys.must_equal expected_filters.keys
     expected_filters.each do |table_name, filter_condition|
-      actual_filters[table_name]["only"].must_be_kind_of String    # TODO test different kinds of filters.
+      actual_filters[table_name]["only"].must_be_kind_of String
     end
   end
 end

data/test/schema.rb

@@ -20,4 +20,14 @@ ActiveRecord::Schema.define(:version => 0) do
     t.references :tag, null: false
     t.timestamps null: false
   end
+
+  create_table :cms_table, :force => true do |t|
+    t.string :cms_id
+    t.string :some_legacy_thing
+  end
+
+  create_table :old_tags, :force => true do |t|
+    t.integer :blog_post_id
+    t.timestamps null: false
+  end
 end

data/test/setup_models.rb

@@ -12,3 +12,11 @@ class PostTag < ActiveRecord::Base
   belongs_to :blog_post
   belongs_to :tag
 end
+
+class OldEntry < ActiveRecord::Base
+  self.table_name = "cms_table"
+end
+
+class OldTag < ActiveRecord::Base
+  belongs_to :old_entry, :foreign_key => 'blog_post_id'
+end

data/test/table_test.rb

@@ -3,8 +3,16 @@ require 'test_helper'
 describe PartialKs::Table do
   describe "#model" do
     it "has a model" do
-      table = PartialKs::Table.new("users")
+      table = PartialKs::Table.new(User)
       table.must_respond_to :model
     end
   end
+
+  describe "candidate parents" do
+    it "returns nothing for a top level table" do
+      table = PartialKs::Table.new(User)
+
+      table.candidate_parent_classes.must_equal []
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: partial_ks
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Thong Kuah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-02 00:00:00.000000000 Z
+date: 2016-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -37,6 +37,7 @@ files:
 - README.md
 - Rakefile
 - lib/partial_ks.rb
+- lib/partial_ks/all_rails_models.rb
 - lib/partial_ks/configuration_generator.rb
 - lib/partial_ks/filtered_table.rb
 - lib/partial_ks/parent_inferrer.rb