prelude-batch-loader 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fe5fd8aaec2a81ab66605e3946294da8f80472e3edd5a50e6d5a9f191a7eb71f
+  data.tar.gz: 78ae571f78eb8e000aa8cfc675694f78487c9dbe6e926107ca244496262438cc
+SHA512:
+  metadata.gz: 2882a7e26bf8ad5aa63825111ab3550c0e21caf8c512f9bd077d365ae2b54d26acbf4ff550c90f2f5c3536b55fe4b988deeb1fdcada445c2dec13d70bbbaf22d
+  data.tar.gz: 95c16f16fd51bf401cadf44b5105b4ed3dc7b9a8e7796060c148ef211fe1be75019d7977758d8d31bd786551b9293cc427ca0e5ab26206cae6d255ea1ad8ab7f

data/lib/prelude.rb

@@ -0,0 +1,13 @@
+require_relative 'prelude/version'
+require_relative 'prelude/preloadable'
+require_relative 'prelude/relation'
+require_relative 'prelude/enumerator'
+require 'active_support'
+
+ActiveSupport.on_load :active_record do
+  include Prelude::Preloadable
+  ActiveRecord::Relation.prepend Prelude::Relation
+end
+
+# Patch into Enumerator to support with_prelude
+Enumerator.include(Prelude::Enumerator)

data/lib/prelude/enumerator.rb

@@ -0,0 +1,18 @@
+module Prelude
+  module Enumerator
+    TypeMismatch = Class.new(StandardError)
+
+    def with_prelude
+      return to_enum(:with_prelude) unless block_given?
+
+      raise TypeMismatch unless map(&:class).uniq.count == 1
+
+      # Share a preloader
+      preloader = Preloader.new(first.class, self)
+      each { |r| r.prelude_preloader = preloader }
+
+      # Iterate
+      each { |o| yield o }
+    end
+  end
+end

data/lib/prelude/method.rb

@@ -0,0 +1,14 @@
+module Prelude
+  class Method
+    attr_reader :batch_size
+
+    def initialize(batch_size:, &blk)
+      @batch_size = batch_size
+      @definition = blk
+    end
+
+    def call(*args)
+      @definition.call(*args)
+    end
+  end
+end

data/lib/prelude/preloadable.rb

@@ -0,0 +1,30 @@
+require_relative './preloader'
+require_relative './method'
+
+module Prelude
+  module Preloadable
+    extend ActiveSupport::Concern
+
+    attr_writer :prelude_preloader
+
+    class_methods do
+      # Mapping of field name to block for resolving a given preloader
+      def prelude_methods
+        @prelude_methods ||= {}
+      end
+
+      # Define how to preload a given method
+      def define_prelude(name, batch_size: nil, &blk)
+        prelude_methods[name] = Prelude::Method.new(batch_size: batch_size, &blk)
+
+        define_method(name) do |*args|
+          unless @prelude_preloader
+            @prelude_preloader = Preloader.new(self.class, [self])
+          end
+
+          @prelude_preloader.fetch(name, self, *args)
+        end
+      end
+    end
+  end
+end

data/lib/prelude/preloader.rb

@@ -0,0 +1,61 @@
+module Prelude
+  class Preloader
+    def initialize(klass, records)
+      @klass = klass
+      @records = records
+      @runs = {}
+    end
+
+    def fetch(name, object, *args)
+      method = @klass.prelude_methods.fetch(name)
+
+      # If this object has a run, return the value
+      if run = run_for(method, args, object)
+        return run[object]
+      end
+
+      # Choose a batch of the correct size that contains the object we're trying to load,
+      # or use all if we're not batching
+      run = if method.batch_size
+        remaining_records = @records.to_a - resolved_objects_for(method, args)
+        slices = remaining_records.each_slice(method.batch_size)
+        slice = slices.detect { |slice| slice.include?(object) }
+        preload(method, slice, args)
+      else
+        preload(method, @records, args)
+      end
+
+      # Return the value for this object
+      run[object]
+    end
+
+    private
+
+    # Preload the given field with the given args for all records
+    def preload(method, records, args)
+      results = method.call(records, *args)
+
+      # set the run for each of these name/record/args combos
+      records.each do |record|
+        set_run_for(method, args, record, results)
+      end
+
+      # Return the run
+      results
+    end
+
+    def run_for(method, args, object)
+      @runs.dig(method, args, object)
+    end
+
+    def resolved_objects_for(method, args)
+      @runs.dig(method, args)&.keys || []
+    end
+
+    def set_run_for(method, args, object, run)
+      @runs[method] ||= {}
+      @runs[method][args] ||= {}
+      @runs[method][args][object] = run
+    end
+  end
+end

data/lib/prelude/relation.rb

@@ -0,0 +1,14 @@
+module Prelude
+  module Relation
+    def preload_associations(records)
+      # Keep existing behavior
+      super(records)
+
+      # Add in our behavior
+      if Preloadable === records.first
+        preloader = Preloader.new(records.first.class, records)
+        records.each { |r| r.prelude_preloader = preloader }
+      end
+    end
+  end
+end

data/lib/prelude/version.rb

@@ -0,0 +1,3 @@
+module Prelude
+  VERSION = [0, 0, 3].join('.')
+end

data/spec/prelude_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Prelude do
+  it 'should have a version' do
+    expect(Prelude::VERSION).to_not be_nil
+  end
+
+  it 'should be able to call preloaders on a single instance' do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number) do |records|
+        Hash.new { |h, k| h[k] = 42 } # answer is always 42
+      end
+    end
+
+    expect(klass.new.number).to eq(42)
+  end
+
+  it 'should be able to batch multiple calls into one' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number) do |records|
+        call_count += 1
+        Hash[records.map { |r| [r, 42] }]  # answer is always 42
+      end
+    end
+
+    5.times { klass.create! }
+
+    expect(klass.all.map(&:number).uniq).to eq([42]) # all the same result
+    expect(call_count).to eq(1) # only one call
+  end
+
+  it 'should be able to work with Arrays' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number) do |records|
+        call_count += 1
+        Hash.new { |h, k| h[k] = 42 } # answer is always 42
+      end
+    end
+
+    records = 5.times.map { klass.new }
+    numbers = records.map.with_prelude(&:number)
+
+    expect(numbers.uniq).to eq([42]) # all the same result
+    expect(call_count).to eq(1) # only one call
+  end
+
+  it 'should be able to chain Enumerators' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number) do |records|
+        call_count += 1
+        Hash.new { |h, k| h[k] = 42 } # answer is always 42
+      end
+    end
+
+    records = 5.times.map { klass.new }
+    numbers = records.map.with_prelude.with_index do |record, i|
+      expect(record).to be_present
+      expect(i).to be_a(Integer)
+      record.number
+    end
+
+    expect(numbers.uniq).to eq([42]) # all the same result
+    expect(call_count).to eq(1) # only one call
+  end
+
+  it 'should raise an error if there is a type mismatch in the Array' do
+    expect {
+      [1, "two"].each.with_prelude.to_a
+    }.to raise_error(Prelude::Enumerator::TypeMismatch)
+  end
+
+  it 'should memoize when called on a single item' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number) do |records|
+        call_count += 1
+        Hash.new { |h, k| h[k] = 42 } # answer is always 42
+      end
+    end
+
+    record = klass.new
+    numbers = 5.times.map { record.number }
+
+    expect(numbers.uniq).to eq([42]) # all the same result
+    expect(call_count).to eq(1) # only one call
+  end
+
+  it 'should be able to pass arguments to methods' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:multiply_by) do |records, by|
+        call_count += 1
+        Hash.new { |h, k| h[k] = 42 * by }
+      end
+    end
+
+    instances = 3.times.map { klass.new }
+
+    instances.each.with_prelude do |i|
+      expect(i.multiply_by(1)).to eq(42)
+      expect(i.multiply_by(1)).to eq(42)
+      expect(i.multiply_by(2)).to eq(84)
+    end
+
+    expect(call_count).to eq(2) # one for each argument
+  end
+
+  it 'should be able to set a batch size' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number, batch_size: 2) do |records|
+        call_count += 1
+        Hash[records.map { |r| [r, 42] }]
+      end
+    end
+
+    values = 4.times.map { klass.new }.map.with_prelude { |r| r.number }
+
+    expect(values.uniq).to eq([42])
+    expect(call_count).to eq(4 / 2) # one per batch
+  end
+
+  it 'should be able to use batch_size with default_proc' do
+    call_count = 0
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'breweries'
+
+      define_prelude(:number, batch_size: 2) do |records|
+        call_count += 1
+        Hash.new { |h, k| h[k] = 42 }
+      end
+    end
+
+    values = 4.times.map { klass.new }.map.with_prelude { |r| r.number }
+
+    expect(values.uniq).to eq([42])
+    expect(call_count).to eq(4 / 2) # one per batch
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+require 'active_record'
+require 'pry'
+require_relative '../lib/prelude'
+
+# Remove existing
+FileUtils.rm_rf('db.sqlite3')
+
+# Connect
+ActiveRecord::Base.establish_connection(
+  adapter:  "sqlite3",
+  host:     "localhost",
+  database: "db.sqlite3"
+)
+
+# Create the appropriate structure
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define do
+  create_table :breweries do |table|
+    table.column :name, :string
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: prelude-batch-loader
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- John Crepezzi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description:
+email: john.crepezzi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/prelude.rb
+- lib/prelude/enumerator.rb
+- lib/prelude/method.rb
+- lib/prelude/preloadable.rb
+- lib/prelude/preloader.rb
+- lib/prelude/relation.rb
+- lib/prelude/version.rb
+- spec/prelude_spec.rb
+- spec/spec_helper.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: ActiveRecord custom preloading
+test_files:
+- spec/spec_helper.rb
+- spec/prelude_spec.rb