ams_lazy_relationships 0.1.4 → 0.3.2

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/Bajena/ams_lazy_relationships.svg?branch=master)](https://travis-ci.org/Bajena/ams_lazy_relationships)
+[![Build Status](https://travis-ci.com/Bajena/ams_lazy_relationships.svg?branch=master)](https://travis-ci.com/Bajena/ams_lazy_relationships)
 [![Maintainability](https://api.codeclimate.com/v1/badges/c21b988e09db63396309/maintainability)](https://codeclimate.com/github/Bajena/ams_lazy_relationships/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/c21b988e09db63396309/test_coverage)](https://codeclimate.com/github/Bajena/ams_lazy_relationships/test_coverage)
 
@@ -63,8 +63,10 @@ class UserSerializer < BaseSerializer
   
   # The previous one is a shorthand for the following lines:
   lazy_relationship :blog_posts, loader: AmsLazyRelationships::Loaders::Association.new("User", :blog_posts)
-  has_many :blog_posts, serializer: BlogPostSerializer do
-    lazy_blog_posts
+  has_many :blog_posts, serializer: BlogPostSerializer do |serializer|
+    # non-proc custom finder will work as well, but it can produce redundant sql
+    # queries, please see [Example 2: Modifying the relationship before rendering](#example-2-modifying-the-relationship-before-rendering)
+    -> { serializer.lazy_blog_posts }
   end
    
   lazy_has_one :poro_model, loader: AmsLazyRelationships::Loaders::Direct.new(:poro_model) { |object| PoroModel.new(object) }
@@ -116,10 +118,43 @@ end
 #### Example 2: Modifying the relationship before rendering
 Sometimes it may happen that you need to process the relationship before rendering, e.g. decorate the records. In this case the gem provides a special method (in our case `lazy_comments`) for each defined relationship. Check out the example - we'll decorate every comment before serializing:
 
+```ruby
+class BlogPostSerializer < BaseSerializer
+  lazy_has_many :comments do |serializer|
+    -> { serializer.lazy_comments.map(&:decorate) }
+   end
+end
+```
+
+Despite the fact that non-block custom finder such as
+
+```ruby
+class BlogPostSerializer < BaseSerializer
+  lazy_has_many :comments do |serializer|
+    serializer.lazy_comments.map(&:decorate)
+   end
+end
+```
+
+will work still, it's better to implement it in a form of lambda, in order to avoid redundant SQL queries when `include_data` AMS setting appears to be `false`:
+
+```ruby
+class BlogPostSerializer < BaseSerializer
+  lazy_has_many :comments do |serializer|
+    include_data :if_sideloaded
+    -> { serializer.lazy_comments.map(&:decorate) }
+   end
+end
+```
+
+Feel free to skip custom lazy finder for association if your goal is just to define `include_data` setting and/or to specify some links and metas:
+
 ```ruby
 class BlogPostSerializer < BaseSerializer
   lazy_has_many :comments do
-    lazy_comments.map(&:decorate)
+    include_data :if_sideloaded
+    link :self, 'a link'
+    meta name: 'Dan Brown'
    end
 end
 ```
@@ -163,6 +198,24 @@ class BlogPostSerializer < BaseSerializer
 end
 ```
 
+#### Example 6: Lazy dig through relationships
+In additional to previous example you may want to make use of nested lazy relationship without rendering of any nested record.
+There is an `lazy_dig` method to be used for that:
+
+```ruby
+class AuthorSerializer < BaseSerializer
+  lazy_relationship :address
+end
+
+class BlogPostSerializer < BaseSerializer
+  lazy_relationship :author
+
+  attribute :author_address do
+    lazy_dig(:author, :address)&.full_address
+  end
+end
+```
+
 ## Performance comparison with vanilla AMS
 
 In general the bigger and more complex your serialized records hierarchy is and the more latency you have in your DB the more you'll benefit from using this gem. 

data/RELEASE.md

@@ -1,11 +1,12 @@
 # Release steps
 1. Bump VERSION constant
-2. Generate changelog and update 
+2. Generate changelog and update
 ```shell
 CHANGELOG_GITHUB_TOKEN=<token> bundle exec rake changelog
 ```
 3. Run `bundle` to regenerate Gemfile.lock
-4. Build and push to rubygems
+4. Commit & push a new tag
+5. Build and push to rubygems
 ```shell
 gem build ams_lazy_relationships
 gem push ams_lazy_relationships-x.y.z.gem

data/Rakefile

@@ -3,6 +3,7 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 require "github_changelog_generator/task"
+require "ams_lazy_relationships/version"
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -11,5 +12,5 @@ task default: :spec
 GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.user = "Bajena"
   config.project = "ams_lazy_relationships"
-  config.future_release = "v0.1.4"
+  config.future_release = "v#{AmsLazyRelationships::VERSION}"
 end

data/ams_lazy_relationships.gemspec

@@ -33,30 +33,32 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "active_model_serializers"
-  spec.add_dependency "batch-loader", "~> 1"
+  spec.add_dependency "active_model_serializers", ">= 0.10.0.rc4"
+  spec.add_dependency "batch-loader"
 
   spec.add_development_dependency "activerecord"
   # A Ruby library for testing against different versions of dependencies
   spec.add_development_dependency "appraisal"
-  spec.add_development_dependency "bundler", "~> 1.17"
   # Rspec matchers for SQL query counts
   spec.add_development_dependency "db-query-matchers"
   spec.add_development_dependency "github_changelog_generator"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-nav"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-rails", "~> 3.5"
   spec.add_development_dependency "rubocop", "= 0.61.0"
   spec.add_development_dependency "rubocop-rspec", "= 1.20.1"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "simplecov-lcov"
-  spec.add_development_dependency "sqlite3", "~> 1.3.6"
+  spec.add_development_dependency "sqlite3"
   # Detect untested code blocks in recent changes
   spec.add_development_dependency "undercover"
   # Dynamically build an Active Record model (with table) within a test context
-  spec.add_development_dependency "with_model", "~> 2.0"
+  spec.add_development_dependency "with_model"
+
+  # Implicit dependency of AMS - used to be a part of Rails
+  spec.add_development_dependency "thread_safe"
 
   spec.add_development_dependency "benchmark-memory", "~> 0.1"
 end

data/gemfiles/ams_0.10.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "active_model_serializers", "0.10.0"
+
+gemspec path: "../"

data/gemfiles/ams_0.10.10.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "active_model_serializers", "0.10.10"
+
+gemspec path: "../"

data/gemfiles/ams_0.10.3.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "active_model_serializers", "0.10.3"
+
+gemspec path: "../"

data/gemfiles/batch_loader_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "batch-loader", "~> 1"
+
+gemspec path: "../"

data/gemfiles/batch_loader_2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "batch-loader", "~> 2"
+
+gemspec path: "../"

data/lib/ams_lazy_relationships.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require "batch-loader"
+require "active_model_serializers"
+
 require "ams_lazy_relationships/version"
+require "ams_lazy_relationships/extensions"
 require "ams_lazy_relationships/loaders"
 require "ams_lazy_relationships/core"
 

data/lib/ams_lazy_relationships/core.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ams_lazy_relationships/core/lazy_relationship_method"
+require "ams_lazy_relationships/core/lazy_dig_method"
 require "ams_lazy_relationships/core/relationship_wrapper_methods"
 require "ams_lazy_relationships/core/evaluation"
 
@@ -18,6 +19,7 @@ module AmsLazyRelationships::Core
 
   def self.included(klass)
     klass.send :extend, ClassMethods
+    klass.send :include, LazyDigMethod
     klass.send :prepend, Initializer
 
     klass.send(:define_relationship_wrapper_methods)
@@ -48,7 +50,7 @@ module AmsLazyRelationships::Core
     def initialize(*)
       super
 
-      self.class.send(:load_all_lazy_relationships, object)
+      self.class.send(:init_all_lazy_relationships, object)
     end
   end
 end

data/lib/ams_lazy_relationships/core/evaluation.rb

@@ -8,26 +8,47 @@ module AmsLazyRelationships::Core
     LAZY_NESTING_LEVELS = 3
     NESTING_START_LEVEL = 1
 
+    # Loads the lazy relationship
+    #
+    # @param relation_name [Symbol] relation name to be loaded
+    # @param object [Object] Lazy relationships will be loaded for this record.
+    def load_lazy_relationship(relation_name, object)
+      lrm = lazy_relationships[relation_name]
+      unless lrm
+        raise ArgumentError, "Undefined lazy '#{relation_name}' relationship for '#{name}' serializer"
+      end
+
+      # We need to evaluate the promise right before serializer tries
+      # to touch it. Otherwise the various side effects can happen:
+      # 1. AMS will attempt to serialize nil values with a specific V1 serializer
+      # 2. `lazy_association ? 'exists' : 'missing'` expression will always
+      #     equal to 'exists'
+      # 3. `lazy_association&.id` expression can raise NullPointer exception
+      #
+      # Calling `__sync` will evaluate the promise.
+      init_lazy_relationship(lrm, object).__sync
+    end
+
     # Recursively loads the tree of lazy relationships
     # The nesting is limited to 3 levels.
     #
     # @param object [Object] Lazy relationships will be loaded for this record.
     # @param level [Integer] Current nesting level
-    def load_all_lazy_relationships(object, level = NESTING_START_LEVEL)
+    def init_all_lazy_relationships(object, level = NESTING_START_LEVEL)
       return if level >= LAZY_NESTING_LEVELS
       return unless object
 
       return unless lazy_relationships
 
       lazy_relationships.each_value do |lrm|
-        load_lazy_relationship(lrm, object, level)
+        init_lazy_relationship(lrm, object, level)
       end
     end
 
     # @param lrm [LazyRelationshipMeta] relationship data
     # @param object [Object] Object to load the relationship for
     # @param level [Integer] Current nesting level
-    def load_lazy_relationship(lrm, object, level = NESTING_START_LEVEL)
+    def init_lazy_relationship(lrm, object, level = NESTING_START_LEVEL)
       load_for_object = if lrm.load_for.present?
                           object.public_send(lrm.load_for)
                         else
@@ -35,7 +56,7 @@ module AmsLazyRelationships::Core
                         end
 
       lrm.loader.load(load_for_object) do |batch_records|
-        deep_load_for_yielded_records(
+        deep_init_for_yielded_records(
           batch_records,
           lrm,
           level
@@ -43,14 +64,28 @@ module AmsLazyRelationships::Core
       end
     end
 
-    def deep_load_for_yielded_records(batch_records, lrm, level)
+    def deep_init_for_yielded_records(batch_records, lrm, level)
       # There'll be no more nesting if there's no
       # reflection for this relationship. We can skip deeper lazy loading.
       return unless lrm.reflection
 
       Array.wrap(batch_records).each do |r|
-        lrm.serializer_class.send(:load_all_lazy_relationships, r, level + 1)
+        deep_init_for_yielded_record(r, lrm, level)
       end
     end
+
+    def deep_init_for_yielded_record(batch_record, lrm, level)
+      serializer = lazy_serializer_for(batch_record, lrm: lrm)
+      return unless serializer
+
+      serializer.send(:init_all_lazy_relationships, batch_record, level + 1)
+    end
+
+    def lazy_serializer_for(object, lrm: nil, relation_name: nil)
+      lrm ||= lazy_relationships[relation_name]
+      return unless lrm&.reflection
+
+      serializer_for(object, lrm.reflection.options)
+    end
   end
 end

data/lib/ams_lazy_relationships/core/lazy_dig_method.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module AmsLazyRelationships::Core
+  # Provides `lazy_dig` as an instance method for serializers, in order to make
+  # possible to dig relationships in depth just like `Hash#dig` do, keeping the
+  # laziness and N+1-free evaluation.
+  module LazyDigMethod
+    # @param relation_names [Array<Symbol>] the sequence of relation names
+    #   to dig through.
+    # @return [ActiveRecord::Base, Array<ActiveRecord::Base>, nil] ActiveRecord
+    #   objects found by digging through the sequence of nested relationships.
+    #   Singular or plural nature of returned value depends from the
+    #   singular/plural nature of the chain of relation_names.
+    #
+    # @example
+    #   class AuthorSerializer < BaseSerializer
+    #     lazy_belongs_to :address
+    #     lazy_has_many :rewards
+    #   end
+    #
+    #   class BlogPostSerializer < BaseSerializer
+    #     lazy_belongs_to :author
+    #
+    #     attribute :author_address do
+    #       # returns single AR object or nil
+    #       lazy_dig(:author, :address)&.full_address
+    #     end
+    #
+    #     attribute :author_rewards do
+    #       # returns an array of AR objects
+    #       lazy_dig(:author, :rewards).map(&:description)
+    #     end
+    #   end
+    def lazy_dig(*relation_names)
+      relationships = {
+        multiple: false,
+        data: [{
+          serializer: self.class,
+          object: object
+        }]
+      }
+
+      relation_names.each do |relation_name|
+        lazy_dig_relationship!(relation_name, relationships)
+      end
+
+      objects = relationships[:data].map { |r| r[:object] }
+
+      relationships[:multiple] ? objects : objects.first
+    end
+
+    private
+
+    def lazy_dig_relationship!(relation_name, relationships)
+      relationships[:data].map! do |data|
+        serializer = data[:serializer]
+        object = data[:object]
+
+        next_objects = lazy_dig_next_objects!(relation_name, serializer, object)
+        next unless next_objects
+
+        relationships[:multiple] ||= next_objects.respond_to?(:to_ary)
+
+        lazy_dig_next_relationships!(relation_name, serializer, next_objects)
+      end
+
+      relationships[:data].flatten!
+      relationships[:data].compact!
+    end
+
+    def lazy_dig_next_objects!(relation_name, serializer, object)
+      serializer&.send(
+        :load_lazy_relationship,
+        relation_name,
+        object
+      )
+    end
+
+    def lazy_dig_next_relationships!(relation_name, serializer, next_objects)
+      Array.wrap(next_objects).map do |next_object|
+        next_serializer = serializer.send(
+          :lazy_serializer_for,
+          next_object,
+          relation_name: relation_name
+        )
+
+        {
+          serializer: next_serializer,
+          object: next_object
+        }
+      end
+    end
+  end
+end

data/lib/ams_lazy_relationships/core/lazy_relationship_meta.rb

@@ -19,17 +19,5 @@ module AmsLazyRelationships::Core
     end
 
     attr_reader :name, :loader, :reflection, :load_for
-
-    # @return [ActiveModel::Serializer] AMS Serializer class for the relationship
-    def serializer_class
-      return @serializer_class if defined?(@serializer_class)
-
-      @serializer_class =
-        if AmsLazyRelationships::Core.ams_version <= Gem::Version.new("0.10.0.rc2")
-          reflection[:association_options][:serializer]
-        else
-          reflection.options[:serializer]
-        end
-    end
   end
 end