ar_lazy_preload 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18eb45f9e1c299f719a7bdde76d9da3c9de0175919ad71556c4dfee750405d35
+  data.tar.gz: cec719881cff10f3687c8a22461d0b27acf9ab064104cbb5fb380eb6bd836701
+SHA512:
+  metadata.gz: 71d13fa6015289abc893816b695e920fb59c42d96691d5cd86c3ce41c2c5e4bb34e5c6ea343094aabd39136e4e01ef1e88cd1f5e50bf97968f074844b61b3d87
+  data.tar.gz: 5e4e2f0f95b42796d7f165afb7009db76fbbcfa083e2552c2b7c90e7bc9442445d533cdfd498dc8a39b4734e8c0e50641ea8d77f48a429a85568fb0421e72c3c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 DmitryTsepelev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+[![Build Status](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload.svg?branch=master)](https://travis-ci.org/DmitryTsepelev/ar_lazy_preload)
+[![Maintainability](https://api.codeclimate.com/v1/badges/00d04595661820dfba80/maintainability)](https://codeclimate.com/github/DmitryTsepelev/ar_lazy_preload/maintainability)
+[![Coverage Status](https://coveralls.io/repos/github/DmitryTsepelev/ar_lazy_preload/badge.svg?branch=master)](https://coveralls.io/github/DmitryTsepelev/ar_lazy_preload?branch=master)
+
+# ArLazyPreload
+
+Lazy loading associations for the ActiveRecord models. `#includes`, `#eager_load` and `#preload` are built-in methods to avoid N+1 problem, but sometimes when DB request is made we don't know what associations we are going to need later (for instance when your API allows client to define a list of loaded associations dynamically). The only possible solution for such cases is to load _all_ the associations we might need, but it can be a huge overhead.
+
+This gem allows to set up _lazy_ preloading for associations - it won't load anything until association is called for a first time, but when it happens - it loads all the associated records for all records from the initial relation in a single query.
+
+For example, if we define a following relation
+
+```ruby
+users = User.lazy_preload(:posts).limit(10)
+```
+
+and use it in a following way
+
+```ruby
+users.map(&:first_name)
+```
+
+there will be one query because we've never accessed posts:
+
+```sql
+SELECT * FROM users LIMIT 10
+```
+
+Hovever, when we try to load posts
+
+```ruby
+users.map(&:posts)
+```
+
+there will be one more request for posts:
+
+```sql
+SELECT * FROM posts WHERE user_id in (...)
+```
+
+## Installation
+
+Add this line to your application's Gemfile, and you're all set:
+
+```ruby
+gem "ar_lazy_preload"
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]

data/lib/ar_lazy_preload.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "ar_lazy_preload/ext/base"
+require "ar_lazy_preload/ext/relation"
+require "ar_lazy_preload/ext/association"
+require "ar_lazy_preload/ext/merger"
+require "ar_lazy_preload/ext/association_relation"
+
+module ArLazyPreload
+  ActiveRecord::Base.include(ArLazyPreload::Base)
+
+  ActiveRecord::Relation.prepend(ArLazyPreload::Relation)
+  ActiveRecord::AssociationRelation.prepend(ArLazyPreload::AssociationRelation)
+  ActiveRecord::Relation::Merger.prepend(ArLazyPreload::Merger)
+
+  [
+    ActiveRecord::Associations::CollectionAssociation,
+    ActiveRecord::Associations::Association
+  ].each { |klass| klass.prepend(ArLazyPreload::Association) }
+end

data/lib/ar_lazy_preload/associated_context_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "ar_lazy_preload/association_tree_builder"
+
+module ArLazyPreload
+  # This class is responsible for building context for associated records. Given a list of records
+  # belonging to the same context and association name it will create and attach a new context to
+  # the associated records based on the parent association tree.
+  class AssociatedContextBuilder
+    attr_reader :parent_context, :association_name
+
+    def initialize(parent_context:, association_name:)
+      @parent_context = parent_context
+      @association_name = association_name
+    end
+
+    delegate :records, :association_tree, :model, to: :parent_context
+
+    # Takes all the associated records for the records, attached to the :parent_context and creates
+    # a preloading context for them
+    def perform
+      return if child_association_tree.blank? || associated_records.blank?
+
+      Context.new(
+        model: reflection.klass,
+        records: associated_records,
+        association_tree: child_association_tree
+      )
+    end
+
+    private
+
+    def child_association_tree
+      @child_association_tree ||= association_tree_builder.subtree_for(association_name)
+    end
+
+    def association_tree_builder
+      @association_tree_builder ||= AssociationTreeBuilder.new(association_tree)
+    end
+
+    def associated_records
+      @associated_records ||=
+        if reflection.collection?
+          record_associations.map(&:target).flatten
+        else
+          record_associations
+        end
+    end
+
+    def reflection
+      @reflection = model.reflect_on_association(association_name)
+    end
+
+    def record_associations
+      @record_associations ||= records.map { |record| record.send(association_name) }
+    end
+  end
+end

data/lib/ar_lazy_preload/association_tree_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # This class is responsible for building association subtrees from a given association tree
+  # For instance, given a following tree `[:users, { users: :comments }]`,
+  # #subtree_for will build a subtree `[:comments]` when :users argument is passed
+  class AssociationTreeBuilder
+    attr_reader :association_tree
+
+    def initialize(association_tree)
+      @association_tree = association_tree.select { |node| node.is_a?(Hash) }
+    end
+
+    def subtree_for(association)
+      subtree_cache[association]
+    end
+
+    private
+
+    def subtree_cache
+      @subtree_cache ||= Hash.new do |hash, association|
+        hash[association] = association_tree.map { |node| node[association] }
+      end
+    end
+  end
+end

data/lib/ar_lazy_preload/context.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "ar_lazy_preload/associated_context_builder"
+
+module ArLazyPreload
+  # This class is responsible for holding a connection between a list of ActiveRecord::Base objects
+  # which have been loaded by the same instance of ActiveRecord::Relation. It also contains a tree
+  # of associations, which were requested to be loaded lazily.
+  # Calling #preload_association method will cause loading of ALL associated objects for EACH
+  # ecord when requested association is found in the association tree.
+  class Context
+    attr_reader :model, :records, :association_tree
+
+    # :model - ActiveRecord class which records belong to
+    # :records - array of ActiveRecord instances
+    # :association_tree - list of symbols or hashes representing a tree of preloadable associations
+    def initialize(model:, records:, association_tree:)
+      @model = model
+      @records = records.compact
+      @association_tree = association_tree
+
+      @records.each { |record| record.lazy_preload_context = self }
+    end
+
+    # This method checks if the association is present in the association_tree and preloads for all
+    # objects in the context it if needed.
+    def try_preload_lazily(association_name)
+      return unless association_needs_preload?(association_name)
+
+      preloader.preload(records, association_name)
+
+      AssociatedContextBuilder.new(
+        parent_context: self,
+        association_name: association_name
+      ).perform
+    end
+
+    private
+
+    def association_needs_preload?(association_name)
+      association_tree.any? do |node|
+        if node.is_a?(Symbol)
+          node == association_name
+        elsif node.is_a?(Hash)
+          node.key?(association_name)
+        end
+      end
+    end
+
+    def preloader
+      @preloader ||= ActiveRecord::Associations::Preloader.new
+    end
+  end
+end

data/lib/ar_lazy_preload/ext/association.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # ActiveRecord::Association patch with a hook for lazy preloading
+  module Association
+    def load_target
+      owner.try_preload_lazily(association_name)
+      super
+    end
+
+    private
+
+    def association_name
+      @association_name ||= reflection.name
+    end
+  end
+end

data/lib/ar_lazy_preload/ext/association_relation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # ActiveRecord::AssociationRelation patch for setting up lazy_preload_values based on
+  # owner context
+  module AssociationRelation
+    def initialize(*args)
+      super(*args)
+
+      context = owner.lazy_preload_context
+      return if context.blank?
+
+      association_tree_builder = AssociationTreeBuilder.new(context.association_tree)
+      subtree = association_tree_builder.subtree_for(reflection.name)
+
+      lazy_preload!(subtree)
+    end
+
+    delegate :owner, :reflection, to: :proxy_association
+  end
+end

data/lib/ar_lazy_preload/ext/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # ActiveRecord::Base patch with lazy preloading support
+  module Base
+    def self.included(base)
+      base.class.delegate :lazy_preload, to: :all
+    end
+
+    attr_accessor :lazy_preload_context
+
+    # When context has been set, this method would cause preloading association with a given name
+    def try_preload_lazily(association_name)
+      lazy_preload_context.try_preload_lazily(association_name) if lazy_preload_context.present?
+    end
+  end
+end

data/lib/ar_lazy_preload/ext/merger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  # ActiveRecord::Relation::Merger patch implementing merge functionality
+  # for lazy preloadable relations
+  module Merger
+    # Enhanced #merge implements merging lazy_preload_values
+    def merge
+      result = super
+
+      if other.lazy_preload_values
+        if other.klass == relation.klass
+          merge_lazy_preloads
+        else
+          reflect_and_merge_lazy_preloads
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def merge_lazy_preloads
+      relation.lazy_preload!(*other.lazy_preload_values)
+    end
+
+    def reflect_and_merge_lazy_preloads
+      reflection = relation.klass.reflect_on_all_associations.find do |r|
+        r.class_name == other.klass.name
+      end
+      return unless reflection
+
+      relation.lazy_preload!(reflection.name => other.lazy_preload_values)
+    end
+  end
+end

data/lib/ar_lazy_preload/ext/relation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "ar_lazy_preload/context"
+
+module ArLazyPreload
+  # ActiveRecord::Relation patch with lazy preloading support
+  module Relation
+    # Enhanced #load method will check if association has not been loaded yet and add a context
+    # for lazy preloading to loaded each record
+    def load
+      need_context = !loaded?
+      old_load_result = super
+      setup_lazy_preload_context if need_context
+      old_load_result
+    end
+
+    # Specify relationships to be loaded lazily when association is loaded for the first time. For
+    # example:
+    #
+    #   users = User.lazy_preload(:posts)
+    #   users.each do |user|
+    #     user.first_name
+    #   end
+    #
+    # will cause only one SQL request to load users, while
+    #
+    #   users = User.lazy_preload(:posts)
+    #   users.each do |user|
+    #     user.posts.map(&:id)
+    #   end
+    #
+    # will make an additional query.
+    def lazy_preload(*args)
+      check_if_method_has_arguments!(:lazy_preload, args)
+      spawn.lazy_preload!(*args)
+    end
+
+    def lazy_preload!(*args)
+      args.reject!(&:blank?)
+      args.flatten!
+      self.lazy_preload_values += args
+      self
+    end
+
+    def lazy_preload_values
+      @lazy_preload_values ||= []
+    end
+
+    private
+
+    attr_writer :lazy_preload_values
+
+    def setup_lazy_preload_context
+      return if lazy_preload_values.blank? || @records.blank?
+
+      ArLazyPreload::Context.new(
+        model: model,
+        records: @records,
+        association_tree: lazy_preload_values
+      )
+    end
+  end
+end

data/lib/ar_lazy_preload/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ArLazyPreload
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: ar_lazy_preload
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- DmitryTsepelev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: lazy_preload implementation for ActiveRecord models
+email:
+- dmitry.a.tsepelev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/ar_lazy_preload.rb
+- lib/ar_lazy_preload/associated_context_builder.rb
+- lib/ar_lazy_preload/association_tree_builder.rb
+- lib/ar_lazy_preload/context.rb
+- lib/ar_lazy_preload/ext/association.rb
+- lib/ar_lazy_preload/ext/association_relation.rb
+- lib/ar_lazy_preload/ext/base.rb
+- lib/ar_lazy_preload/ext/merger.rb
+- lib/ar_lazy_preload/ext/relation.rb
+- lib/ar_lazy_preload/version.rb
+homepage: https://github.com/DmitryTsepelev/ar_lazy_preload
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: lazy_preload implementation for ActiveRecord models
+test_files: []