partial_ks 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad9df615166ffb1addb9feff9c7a0db7cc73c841
-  data.tar.gz: 9781d32d0230aa6e376822cd9803cfbea2938084
+  metadata.gz: 642d94cc600de50ae308e592033b37eb76332797
+  data.tar.gz: 7df7585728a3fe621ed0200d0a83451e3ee0855e
 SHA512:
-  metadata.gz: 7445c9ebc62962e3ee09bd7650d79545a3af9477c89fdfdf0d81b530713ebe012e90c3abe007cbfeec24df28c1624bfe94935c1794929363ccbc75759d80d7ca
-  data.tar.gz: c5ea6e4a4d723d8e6f86e748bd7f969974bff2775bb18f38ca33c5d5f1a015a15b2df1ceb26e079337541381e8686a3cf5abc6d38c53d95962116007c640c974
+  metadata.gz: ca7b7e3247cfa18f6ba92aa9de44bb2e52f5cee6ff42a61ff64f9c2e6214b61a78f7bcb29d707f210b7062e998abd09c7dd4e4f224f7a1f27b2ce8e4081e989d
+  data.tar.gz: eee97be3e6b61d8f3e05a077217ef7d3b6b0659bf663e45c5b06899c7dd58ca8729811c298cef16c09f0c9fa8de01587997fec3e2d52e0cdc972181e4c24c317

data/CHANGES.md

@@ -1,5 +1,13 @@
 # Changelog
 
+# 0.5.0
+
+* New single entry point, `PartialKs::KitchenSync`. This means that Runner and ConfigurationGenerator are now internal concerns
+
+* Teach ModelsList about #issues - Basically a list of models where its "parent" is a MultiParent. Exposed via PartialKs::KitchenSync#issues
+
+* Various refactors and simplifications
+
 # 0.4.2
 
 Fix an issue where we did not support the new ApplicationRecord convention

data/CONTRIBUTING.md

@@ -2,7 +2,7 @@ This document should tell all you need to know for contributing to this project.
 
 # Testing
 
-Tested with activerecord 4.2.7.1, 4.2.8 and 5.0.2 (on Ruby 2.3.3)
+Tested with activerecord 4.2.7.1, 4.2.8, 5.0.2, 5.1.0 (on Ruby 2.3.3)
 
 
 To install and run tests :

data/README.md

@@ -8,9 +8,7 @@ So how does it work ?
 
 
 ```
-manual_configuration = []
-config = PartialKs::ConfigurationGenerator.new(manual_configuration).call
-PartialKs::Runner.new([config]).run! do |tables_to_filter, tables|
+PartialKs::KitchenSync.new(manual_configuration).run! do |tables_to_filter, tables|
   puts tables_to_filter.inspect
   puts tables.inspect
 end
@@ -27,24 +25,12 @@ manual_configuration = [
 
 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*
+  - PartialKs::KitchenSync
 
-* Rename PartialKs::ConfigurationGenerator#call to something better
-* Minimize Public API
 
 # Not supported
 

data/lib/partial_ks/filtered_table.rb

@@ -3,8 +3,8 @@ module PartialKs
     attr_reader :table, :parent_model, :custom_filter_relation
     delegate :table_name, :to => :table
 
-    def initialize(table, parent_model, custom_filter_relation: nil)
-      @table = table
+    def initialize(model, parent_model, custom_filter_relation: nil)
+      @table = PartialKs::Table.new(model)
       @parent_model = parent_model
       @custom_filter_relation = custom_filter_relation
     end

data/lib/partial_ks/kitchen_sync.rb

@@ -0,0 +1,14 @@
+module PartialKs
+  class KitchenSync
+    attr_reader :models_list
+    delegate :issues, to: :models_list
+
+    def initialize(manual_configuration)
+      @models_list = ModelsList.new(manual_configuration)
+    end
+
+    def run!(&block)
+      Runner.new(models_list.all).run!(&block)
+    end
+  end
+end

data/lib/partial_ks/models_list.rb

@@ -0,0 +1,27 @@
+module PartialKs
+  class ModelsList
+    attr_reader :manual_configuration
+
+    def initialize(manual_configuration)
+      @manual_configuration = manual_configuration
+    end
+
+    def all
+      @all ||= manual_configuration + automatic_configuration_except_manual
+    end
+
+    def issues
+      all.select{|model, parent| parent.is_a?(PartialKs::MultiParent)}
+    end
+
+    private
+    def automatic_configuration_except_manual
+      tables_already_present = manual_configuration.map(&:first).map(&:table_name)
+
+      PartialKs.all_rails_models.reject{|model| tables_already_present.include?(model.table_name) }.map do |model|
+        table = PartialKs::Table.new(model)
+        [table.model, table.inferred_parent_class]
+      end
+    end
+  end
+end

data/lib/partial_ks/runner.rb

@@ -1,9 +1,9 @@
 module PartialKs
   class Runner
-    attr_reader :table_graphs
+    attr_reader :models_list
 
-    def initialize(table_graphs)
-      @table_graphs = table_graphs
+    def initialize(models_list)
+      @models_list = models_list
     end
 
     def run!
@@ -20,7 +20,6 @@ module PartialKs
           end
         end
 
-        # TODO output only tables_to_filter, depending on how KS handles filters
         yield tables_to_filter, table_names
       end
     end
@@ -44,29 +43,31 @@ module PartialKs
     end
 
     protected
+    def filtered_tables
+      @filtered_tables ||= models_list.map {|model, parent, custom_filter| PartialKs::FilteredTable.new(model, parent, custom_filter_relation: custom_filter)}
+    end
+
     def generations
       return @generations if defined?(@generations)
 
       @generations = []
-      table_graphs.each do |filtered_tables|
-        q = []
+      q = []
 
-        filtered_tables.each do |filtered_table|
-          q << filtered_table if filtered_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|
-            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
+        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
-
-          q = next_generation
         end
+
+        q = next_generation
       end
 
       @generations

data/lib/partial_ks/table.rb

@@ -7,14 +7,14 @@ module PartialKs
       @model = model
     end
 
-    # sometimes the table is present, but the model is not defined
-    # e.g. in market specific tables
-    def model?
-      model && model.respond_to?(:table_name)
-    end
-
-    def top_level_table?
-      candidate_parent_classes.empty?
+    def inferred_parent_class
+      if candidate_parent_classes.empty?
+        nil
+      elsif candidate_parent_classes.size == 1
+        candidate_parent_classes.first
+      else
+        MultiParent.new(candidate_parent_classes)
+      end
     end
 
     # NB: can't do polymorphic for now, rails errors on reflection#klass
@@ -23,10 +23,6 @@ module PartialKs
       non_nullable_reflections.reject(&:polymorphic?).map(&:klass)
     end
 
-    def parent_tables
-      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?
@@ -55,4 +51,21 @@ module PartialKs
       end
     end
   end
+
+  class MultiParent
+    attr_reader :parents
+
+    def initialize(parents)
+      @parents = parents
+    end
+
+    def ==(other)
+      table_name == other.table_name if other
+    end
+
+    # only used in comparison in Runner
+    def table_name
+      parents.map(&:table_name).join(",")
+    end
+  end
 end

data/lib/partial_ks/version.rb

@@ -1,3 +1,3 @@
 module PartialKs
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
 end

data/lib/partial_ks.rb

@@ -2,7 +2,7 @@ require 'active_record'
 
 require_relative 'partial_ks/all_rails_models'
 require_relative 'partial_ks/filtered_table'
-require_relative 'partial_ks/parent_inferrer'
 require_relative 'partial_ks/runner'
 require_relative 'partial_ks/table'
-require_relative 'partial_ks/configuration_generator'
+require_relative 'partial_ks/models_list'
+require_relative 'partial_ks/kitchen_sync'

data/partial_ks.gemspec

@@ -10,7 +10,7 @@ EOF
   gem.has_rdoc     = false
   gem.author       = "Thong Kuah"
   gem.email        = "kuahyeow@gmail.com"
-  gem.homepage     = "https://github.com/powershop/partial_ks"
+  gem.homepage     = "https://github.com/fluxfederation/partial_ks"
   gem.license      = "MIT"
 
   gem.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/test/all_rails_models_test.rb

@@ -16,4 +16,15 @@ describe "all rails tables" do
   it "returns the same number of models as the number of tables" do
     PartialKs.all_rails_models.map(&:table_name).sort.must_equal ActiveRecord::Base.connection.tables.sort
   end
+
+  it "does not choke on a table which has had its migration run" do
+    PartialKs.all_rails_models.wont_include NewModel
+  end
+
+  it "can return models with different table_name" do
+    model = OldEntry
+    model.table_name.wont_equal model.name.tableize
+
+    PartialKs.all_rails_models.must_include model
+  end
 end

data/test/configuration_generator_test.rb

@@ -1,10 +1,5 @@
 require 'test_helper'
 
-def generator(manual, tables)
-  PartialKs::ConfigurationGenerator.new(manual, tables).call.
-    map {|f| [f.table_name, f.parent_model, f.custom_filter_relation] }
-end
-
 describe "generating dependencies" do
   let(:manual_configuration) do
     [
@@ -12,39 +7,17 @@ describe "generating dependencies" do
     ]
   end
 
-  # TODO remove redundant test (cf parent_inferrer_test)
-  it "auto infers single belongs-to dependencies" do
-    generator(manual_configuration, models: [User, BlogPost]).
-      must_equal [
-      ["users", nil, User.where(:id => [1])],
-      ["blog_posts", User, nil]
-    ]
+  it "returns the manual_configuration" do
+    result = PartialKs::ModelsList.new(manual_configuration).all
+    result.must_include manual_configuration.first
   end
 
-  # TODO remove redundant test (cf parent_inferrer_test)
-  it "auto infers top level tables" do
-    generator(manual_configuration, models: [User, Tag]).
-      must_equal [
-      ["users", nil, User.where(:id => [1])],
-      ["tags", nil, nil]
-    ]
+  it "processes all models" do
+    result = PartialKs::ModelsList.new(manual_configuration).all
+    result.size.must_equal PartialKs.all_rails_models.size
   end
 
-  it "can return models with different table_name" do
-    model = OldEntry
-    model.table_name.wont_equal model.name.tableize
-
-    generator(manual_configuration, models: [User, model]).
-      must_equal [
-      ["users", nil, User.where(:id => [1])],
-      ["cms_table", nil, nil]
-    ]
-  end
-
-  it "does not choke on a table which has had its migration run" do
-    generator(manual_configuration, models: [User, NewModel]).
-      must_equal [
-      ["users", nil, User.where(:id => [1])],
-    ]
+  it "can identify MultiParent as issues" do
+    PartialKs::ModelsList.new(manual_configuration).issues.map(&:last).map(&:class).must_equal [PartialKs::MultiParent]
   end
 end

data/test/filtered_table_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 describe "kitchen sync filter" do
-  let(:table) { PartialKs::Table.new(PostTag) }
+  let(:model) { PostTag }
   let(:parent) { Minitest::Mock.new }
 
   it "proxies to Table if there's parent only" do
@@ -9,39 +9,39 @@ describe "kitchen sync filter" do
     relation_mock = Minitest::Mock.new
     relation_mock.expect :where_sql, "WHERE tag_id IN (0)"
 
-    filtered_table = PartialKs::FilteredTable.new(table, parent)
-    table.stub table_parent_relation_method, relation_mock do
+    filtered_table = PartialKs::FilteredTable.new(model, parent)
+    filtered_table.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 = PartialKs::FilteredTable.new(model, nil, custom_filter_relation: filter)
     filtered_table.kitchen_sync_filter.must_equal({"only" => '"post_tags"."id" IN (1, 2)'})
   end
 
   it "uses the filter inside a lambda" do
     filter = -> { PostTag.where(:id => [1, 2]) }
-    filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: filter)
+    filtered_table = PartialKs::FilteredTable.new(model, nil, custom_filter_relation: filter)
     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 = PartialKs::FilteredTable.new(model, 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)
+    sql_statement = "select * from #{model.table_name} where #{string_filter}"
+    filtered_table = PartialKs::FilteredTable.new(model, 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
-    filtered_table = PartialKs::FilteredTable.new(table, nil)
+    filtered_table = PartialKs::FilteredTable.new(model, nil)
     filtered_table.kitchen_sync_filter.must_be_nil
   end
 

data/test/parent_inferrer_test.rb

@@ -3,16 +3,16 @@ require 'test_helper'
 describe "inferring parents" do
   it "infers no parent for a top level table" do
     table = PartialKs::Table.new(Tag)
-    PartialKs::ParentInferrer.new(table).inferred_parent_class.must_be_nil
+    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(BlogPost)
-    PartialKs::ParentInferrer.new(table).inferred_parent_class.must_equal User
+    table.inferred_parent_class.must_equal User
   end
 
-  it "infers no parent for a table has multiple belongs_to" do
+  it "infers a multi-parent for a table has multiple belongs_to" do
     table = PartialKs::Table.new(PostTag)
-    lambda { PartialKs::ParentInferrer.new(table).inferred_parent_class }.must_raise PartialKs::ParentInferrer::CannotInfer
+    table.inferred_parent_class.must_equal PartialKs::MultiParent.new([BlogPost, Tag])
   end
 end

data/test/runner_test.rb

@@ -2,29 +2,29 @@ require 'test_helper'
 
 describe 'end to end testing' do
   it "runs without error" do
-    generator_output = PartialKs::ConfigurationGenerator.new([]).call
-    PartialKs::Runner.new([generator_output]).run! do |tables_to_filter, table_names|
-      # left empty
+    count = 0
+    multi_parents = [PostTag]
+
+    generator_output = PartialKs::ModelsList.new([]).all
+    PartialKs::Runner.new(generator_output).run! do |tables_to_filter, table_names|
+      count += table_names.size
     end
+
+    count.must_equal PartialKs.all_rails_models.size - multi_parents.size
   end
 end
 
 describe 'running based on output from generator' do
-  let(:manual_configuration) do
-    [
-      ["users", nil, User.where(:id => [1])],
-    ]
-  end
-
   let(:generator_output) do
     [
-      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),
+      [User, nil, User.where(:id => [1])],
+      [Tag, nil],
+      [BlogPost, User],
+      [PostTag, PartialKs::MultiParent.new([BlogPost, Tag])],
     ]
   end
 
-  let(:runner) { PartialKs::Runner.new([generator_output]) }
+  let(:runner) { PartialKs::Runner.new(generator_output) }
 
   it "reports everything" do
     runner.report.must_equal [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: partial_ks
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Thong Kuah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-14 00:00:00.000000000 Z
+date: 2017-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -69,9 +69,9 @@ files:
 - 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
+- lib/partial_ks/kitchen_sync.rb
+- lib/partial_ks/models_list.rb
 - lib/partial_ks/runner.rb
 - lib/partial_ks/table.rb
 - lib/partial_ks/version.rb
@@ -86,7 +86,7 @@ files:
 - test/setup_models.rb
 - test/table_test.rb
 - test/test_helper.rb
-homepage: https://github.com/powershop/partial_ks
+homepage: https://github.com/fluxfederation/partial_ks
 licenses:
 - MIT
 metadata: {}

data/lib/partial_ks/configuration_generator.rb

@@ -1,66 +0,0 @@
-# Given an initial table graph
-# goes through each table not already in the table graph,
-# and attempts to automatically populate the table into the table graph
-module PartialKs
-  class ConfigurationGenerator
-    attr_reader :manual_configuration
-
-    def initialize(manual_configuration, models: nil)
-      @manual_configuration = manual_configuration
-      @models = models || PartialKs.all_rails_models
-    end
-
-    def call
-      @filtered_tables ||= filtered_tables
-    end
-
-    protected
-    def all_tables
-      @all_tables ||= models.map {|model| PartialKs::Table.new(model) }.select(&:model?).index_by(&:table_name)
-    end
-
-    def models
-      tables_in_database = ActiveRecord::Base.connection.tables
-      @models.select{|model| tables_in_database.include?(model.table_name)}
-    end
-
-    def filtered_tables
-      synced_tables = {}
-
-      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
-        synced_tables[table_name] = PartialKs::FilteredTable.new(all_tables[table_name], parent_model, custom_filter_relation: filter_for_table)
-      end
-
-      all_tables.each do |table_name, table|
-        next if synced_tables[table_name]
-
-        begin
-          inferrer = PartialKs::ParentInferrer.new(table)
-          parent_model = inferrer.inferred_parent_class
-          synced_tables[table_name] = PartialKs::FilteredTable.new(table, parent_model)
-        rescue PartialKs::ParentInferrer::CannotInfer
-          next
-        end
-
-      end
-
-      # TODO remove this side effect. Maybe yield or a different method call ?
-      puts "***************"
-      remaining_size = 0
-      all_tables.each do |table_name, table|
-        next if synced_tables[table_name]
-
-        puts "#{table.table_name} - #{table.parent_tables.join(',')}"
-        remaining_size += 1
-      end
-      puts "WARNING: #{remaining_size} tables has no configuration"
-
-      synced_tables.values
-    end
-
-  end
-end

data/lib/partial_ks/parent_inferrer.rb

@@ -1,21 +0,0 @@
-module PartialKs
-  class ParentInferrer
-    CannotInfer = Class.new(StandardError)
-
-    attr_reader :table
-
-    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"
-      end
-    end
-  end
-end