partial_ks 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b14cf3641f82c08ea9ea16536510c59b950dd0f6
-  data.tar.gz: ee41b04d67e616c72787e953ca341da267b15317
+  metadata.gz: 9f64ccee32ef2fecf6953f2916c03e7d13fc061a
+  data.tar.gz: 2666bf980392217edf9567bee84ebeee87601768
 SHA512:
-  metadata.gz: 5b20e05c16bd828f7c9d0f1797fd95b9a5281f49f251f65cb4353caf176b0ef8891ad9f4aa56225935d2a890d28c223e39c827fa080e85b6713838bf96f177f5
-  data.tar.gz: 0b9d556d6419799d9f05649198fc3b4b40e4658ecd2d08f59ad2a6193af4d27a0d8afbc4b82424cb1e236fbe9b2564bd50cb99a65ded4f8bbd56e2de192fab2c
+  metadata.gz: 4ac534888ca683de0f4e18d6fd97d9ff245440410dc405a79a126ad4c0ff291f283dfd71128b28b95ec6cc1e9e3cad66fde6ce81d07273731b999f6ad8d8ffe1
+  data.tar.gz: f10c7800637417c5a7f8c4a6cc76cdf53d2be2ad9536b208e22a96f6cd1e677fce2fd060123b6844ac021d38fa3389e90621178b9224ff0fac92ddc0f0f9fd48

data/.gitignore

@@ -0,0 +1 @@
+test/test.db

data/CHANGES.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.0.5
+
+API change for `ConfigurationGenerator` - removes `ignored_table_names` option.
+Replaced with `table_names` option.

data/README.md

@@ -10,7 +10,7 @@ So how does it work ?
 
 ```
 manual_configuration = []
-config = PartialKs::ConfigurationGenerator.new().call
+config = PartialKs::ConfigurationGenerator.new(manual_configuration).call
 PartialKs::Runner.new([config]).run!
 ```
 
@@ -25,8 +25,8 @@ manual_configuration = [
 
 TODO :
 
-Rename PartialKs::ConfigurationGenerator#call to something better
-What in the world is the tuples in `manual_configuration` meant to be ?
-Minimize Public API
+* Rename PartialKs::ConfigurationGenerator#call to something better
+* What in the world is the tuples in `manual_configuration` meant to be ?
+* Minimize Public API
 
 

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test

data/lib/partial_ks.rb

@@ -1,6 +1,10 @@
+require 'active_record'
+
 module PartialKs
 end
 
+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'

data/lib/partial_ks/configuration_generator.rb

@@ -2,49 +2,47 @@
 # goes through each table not already in the table graph,
 # and attempts to automatically populate the table into the table graph
 class PartialKs::ConfigurationGenerator
-  attr_reader :table_graph, :ignored_table_names
+  attr_reader :table_graph, :table_names
 
-  def initialize(table_graph, ignored_table_names: [])
+  def initialize(table_graph, table_names: nil)
     @table_graph = table_graph
-    @ignored_table_names = ignored_table_names
+    @table_names = table_names || ActiveRecord::Base.connection.tables
   end
 
   def call
-    @auto_constructed_table_graph ||= auto_construct_table_graph
+    @filtered_tables ||= filtered_tables
   end
 
   protected
   def all_tables
-    @all_tables ||= (ActiveRecord::Base.connection.tables - ignored_table_names).map {|table_name| PartialKs::Table.new(table_name) }.select(&:model?).index_by(&:table_name)
+    @all_tables ||= @table_names.map {|table_name| PartialKs::Table.new(table_name) }.select(&:model?).index_by(&:table_name)
   end
 
-  def auto_construct_table_graph
+  def filtered_tables
     synced_tables = {}
 
-    table_graph.each do |table_name, parent_table, table_graph|
+    table_graph.each do |table_name, specified_parent_model, filter_for_table|
       next unless all_tables[table_name]
 
-      synced_tables[table_name] = [table_name, parent_table, table_graph]
+      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]
-      next unless table.top_level_table?
 
-      synced_tables[table_name] = [table_name, nil]
-    end
-
-    all_tables.each do |table_name, table|
-      next if synced_tables[table_name]
-      next unless table.non_nullable_parent_tables.size == 1
-
-      parent_table_name, _, _ = synced_tables[table.non_nullable_parent_tables.only]
-      parent_table = all_tables[parent_table_name] if parent_table_name
-      next unless parent_table
+      begin
+        inferrer = PartialKs::ParentInferrer.new(table)
+        #TODO get rid of try!
+        parent_model = all_tables[inferrer.inferred_parent_table].try!(:model)
+        synced_tables[table_name] = PartialKs::FilteredTable.new(table, parent_model)
+      rescue PartialKs::ParentInferrer::CannotInfer
+        next
+      end
 
-      synced_tables[table.table_name] = [table_name, parent_table.model]
     end
 
+    # TODO remove this side effect. Maybe yield or a different method call ?
     puts "***************"
     remaining_size = 0
     all_tables.each do |table_name, table|

data/lib/partial_ks/filtered_table.rb

@@ -0,0 +1,14 @@
+class PartialKs::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 filter_condition
+    custom_filter_relation || parent_model
+  end
+end

data/lib/partial_ks/parent_inferrer.rb

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

data/lib/partial_ks/runner.rb

@@ -10,8 +10,9 @@ class PartialKs::Runner
       tables_to_filter = {}
       table_names = []
 
-      generation.each do |table_name, filter_config, depth|
-        table_names << table_name
+      generation.each do |table|
+        table_names << table.table_name
+        filter_config = table.filter_condition
 
         if !filter_config.nil?
           if filter_config.is_a?(ActiveRecord::Relation) || filter_config.respond_to?(:where_sql)
@@ -22,26 +23,25 @@ class PartialKs::Runner
             only_filter = "#{filter_config.to_s.foreign_key} IN (#{[0, *filter_config.pluck(:id)].join(',')})"
           end
 
-          tables_to_filter[table_name] = {"only" => only_filter}
+          tables_to_filter[table.table_name] = {"only" => only_filter}
         end
       end
 
+      # TODO output only tables_to_filter, depending on how KS handles filters
       yield tables_to_filter, table_names
     end
   end
 
   def report
+    result = []
     each_generation.with_index do |generation, depth|
-      generation.each do |table_name, table_graph|
-        print " " * depth
-        puts [table_name, table_graph.try!(:to_s), depth].inspect
+      generation.each do |table|
+        result << [table.table_name, table.parent_model, table.filter_condition, depth]
       end
     end
+    result
   end
 
-  # Yields the following
-  # 1. table name
-  # 2. the foreign key columns used to filter this table, and a lambda that will return the foreign key ids
   def each_generation
     return enum_for(:each_generation) unless block_given?
 
@@ -52,23 +52,23 @@ class PartialKs::Runner
 
   protected
   def generations
-    return @generations if @generations
+    return @generations if defined?(@generations)
 
     @generations = []
     table_graphs.each do |table_graph|
       q = []
 
-      table_graph.each do |table_name, parent_table, configuration_for_table|
-        q << [table_name, configuration_for_table || parent_table] if parent_table.nil?
+      table_graph.each do |table|
+        q << table if table.parent_model.nil?
       end
 
       until q.empty?
         @generations << q
 
         next_generation = []
-        q.each do |table_name, _|
-          table_graph.each do |child_table_name, parent_table, configuration_for_table|
-            next_generation << [child_table_name, configuration_for_table || parent_table] if parent_table && parent_table.table_name == table_name
+        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
           end
         end
 

data/lib/partial_ks/version.rb

@@ -1,3 +1,3 @@
 module PartialKs
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/test/configuration_generator_test.rb

@@ -0,0 +1,34 @@
+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] }
+end
+
+describe "generating dependencies" do
+  let(:manual_configuration) do
+    [
+      ["users", nil, User.where(:id => [1])],
+    ]
+  end
+
+  it "auto infers single belongs-to dependencies" do
+    generator(manual_configuration, table_names: pks_tables("users", "blog_posts")).
+      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]
+    ]
+  end
+end

data/test/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: test/test.db

data/test/filtered_table_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+describe "filter condition" do
+  let(:table) { PartialKs::Table.new("users") }
+
+  it "uses parent as the filter" do
+    parent = Tag
+    filtered_table = PartialKs::FilteredTable.new(table, parent)
+    filtered_table.filter_condition.must_equal parent
+  end
+
+  it "uses the custom filter if provided" do
+    filter = User.where(:id => 1)
+    filtered_table = PartialKs::FilteredTable.new(table, nil, custom_filter_relation: filter)
+    filtered_table.filter_condition.must_equal filter
+  end
+
+  it "returns nil if parent is nil" do
+    filtered_table = PartialKs::FilteredTable.new(table, nil)
+    filtered_table.filter_condition.must_be_nil
+  end
+end

data/test/parent_inferrer_test.rb

@@ -0,0 +1,18 @@
+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
+  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"
+  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
+  end
+end

data/test/runner_test.rb

@@ -0,0 +1,61 @@
+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
+    end
+  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("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),
+    ]
+  end
+
+  let(:runner) { PartialKs::Runner.new([generator_output]) }
+
+  it "reports everything" do
+    runner.report.must_equal [
+      ["users", nil, User.where(:id => [1]), 0],
+      ["tags", nil, nil, 0],
+      ["blog_posts", User, User, 1],
+    ]
+  end
+
+  it "yields all table names" do
+    expected_table_names = generator_output.map(&:table_name)
+    actual_table_names   = []
+    runner.run! do |tables_to_filter, table_names|
+      actual_table_names += table_names
+    end
+
+    actual_table_names.must_equal expected_table_names
+  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}
+    actual_filters       = {}
+
+    runner.run! do |tables_to_filter, table_names|
+      actual_filters.merge!(tables_to_filter)
+    end
+
+    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.
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,23 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users, :force => true do |t|
+    t.string :email
+    t.timestamps null: false
+  end
+
+  create_table :blog_posts, :force => true do |t|
+    t.string :title
+    t.references :user, null: false
+    t.timestamps null: false
+  end
+
+  create_table :tags, :force => true do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+
+  create_table :post_tags, :force => true do |t|
+    t.references :blog_post, null: false
+    t.references :tag, null: false
+    t.timestamps null: false
+  end
+end

data/test/setup_models.rb

@@ -0,0 +1,14 @@
+class User < ActiveRecord::Base
+end
+
+class BlogPost < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Tag < ActiveRecord::Base
+end
+
+class PostTag < ActiveRecord::Base
+  belongs_to :blog_post
+  belongs_to :tag
+end

data/test/table_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+describe PartialKs::Table do
+  describe "#model" do
+    it "has a model" do
+      table = PartialKs::Table.new("users")
+      table.must_respond_to :model
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'minitest/autorun'
+require 'partial_ks'
+
+require 'setup_models'
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.join(File.dirname(__FILE__), "database.yml")))
+ActiveRecord::Base.establish_connection ActiveRecord::Base.configurations['test']
+load(File.join(File.dirname(__FILE__), "/schema.rb"))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: partial_ks
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Thong Kuah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-03 00:00:00.000000000 Z
+date: 2016-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,14 +31,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- CHANGES.md
 - LICENSE.txt
 - README.md
+- Rakefile
 - lib/partial_ks.rb
 - lib/partial_ks/configuration_generator.rb
+- lib/partial_ks/filtered_table.rb
+- lib/partial_ks/parent_inferrer.rb
 - lib/partial_ks/runner.rb
 - lib/partial_ks/table.rb
 - lib/partial_ks/version.rb
 - partial_ks.gemspec
+- test/configuration_generator_test.rb
+- test/database.yml
+- test/filtered_table_test.rb
+- test/parent_inferrer_test.rb
+- test/runner_test.rb
+- test/schema.rb
+- test/setup_models.rb
+- test/table_test.rb
+- test/test_helper.rb
 homepage: https://github.com/powershop/partial_ks
 licenses:
 - MIT
@@ -63,4 +77,13 @@ rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Partial KS
-test_files: []
+test_files:
+- test/configuration_generator_test.rb
+- test/database.yml
+- test/filtered_table_test.rb
+- test/parent_inferrer_test.rb
+- test/runner_test.rb
+- test/schema.rb
+- test/setup_models.rb
+- test/table_test.rb
+- test/test_helper.rb