pluck_map 0.6.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6713a4fb63be352fb7c8d54bbbdb7a559fc4b523093f3cff0a72b9507803a8e
-  data.tar.gz: e7f9e9caea6745daeb1beab73c711fd87656309fd3221422ad027072d6fcd8d7
+  metadata.gz: e5a889fad3cf9ac653fb2140beb4b9e11c3a74686564dbdac7cee79d0c0cb0f6
+  data.tar.gz: 7d544995a42e94eae52ad59ecb6357abedcac9396a26fb801ed4998abdc48445
 SHA512:
-  metadata.gz: ca03d1e1f7e82934ee018c93ac980b7f35c8d9805782de196cb1941b36992880ef19f193d8d9055ac03a3999cf58168503e65ccd74fd10a59d806178c2d8950f
-  data.tar.gz: 48822bd995380e8a97e5166c94f890b010823b55227884c66f06e6d4d36b6baf22c9b577aa3acf9670d2cca186c4dac3ccb6ee165b8c27e7861f89d31c4ba5ce
+  metadata.gz: 83c0063cd6bbac89d8fa4b9d4efab07c43f20dc6a5d0a7216e04b4c127d9e93175e737a0ea37b929f318641255935992ac7160e650fa7675d4a9d9780a150003
+  data.tar.gz: 6a9a3780212e568dd7b5ab56dadb79914e3bebc956fb6d591a054040f9c1819997d6c2a706d1ea7936d62a6a48eefb5b8d85b9335d20f15deeab1940b56784cc

data/.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
 rvm: 2.5.5
 
-# Rails 6 requires Postgres 9.3+
+# we need MySQL 5.7+ to support JSON aggregation
+dist: xenial
+
 addons:
-  postgresql: "9.3"
+  # Rails 6 requires Postgres 9.3+
+  # We need Postgres 9.4+ to support JSON aggregation
+  postgresql: "9.4"
 
 services:
   - postgresql

data/CHANGELOG.md

@@ -1,6 +1,8 @@
-## v0.6.2 (2019 Jun 13)
+## v1.0.0.rc1 (2019 May 12)
 
-* FIX: Allow presenting a subclass of the presenter's model (@kobsy)
+* BREAKING: Remove deprecated features/methods (@boblail)
+* FEATURE: Optimize `to_json` when a presenter doesn't need to process values in Ruby (@boblail)
+* FEATURE: Add `has_many` and `has_one` DSL for presenting nested resources (@boblail)
 
 ## v0.6.1 (2019 May 12)
 

data/README.md

@@ -8,13 +8,14 @@ This library provides a DSL for presenting ActiveRecord::Relations without insta
 
 ### Table of Contents
 
-- [Why PluckMap?](https://github.com/boblail/pluck_map#why-pluckmap)
+- [Why PluckMap?](#why-pluckmap)
 - Usage
-  - [Defining attributes to present](https://github.com/boblail/pluck_map#defining-attributes-to-present)
-  - [Presenting Records](https://github.com/boblail/pluck_map#presenting-records)
-- [Installation](https://github.com/boblail/pluck_map#installation)
-- [Requirements](https://github.com/boblail/pluck_map#requirements)
-- [Development & Contributing](https://github.com/boblail/pluck_map#development)
+  - [Defining attributes to present](#defining-attributes-to-present)
+  - [Relationships](#relationships)
+  - [Presenting Records](#presenting-records)
+- [Installation](#installation)
+- [Requirements](#requirements)
+- [Development & Contributing](#development)
 
 
 ## Why PluckMap?
@@ -207,6 +208,80 @@ presenter = PluckMap[Person].define do
 end
 ```
 
+### Relationships
+
+PluckMap can also describe nested data. There are two special methods in the `define` block that introduce child resources:
+
+ 1. `has_one` will treat the resource as a nested object or null
+ 2. `has_many` will treat the resource as an array of nested objects (which may be empty)
+
+The first argument to either of these methods is the name of an association on the presented model.
+
+You can use either of these methods with any kind of ActiveRecord relation (`belongs_to`, `has_one`, `has_many`, `has_and_belongs_to_many`), although it generally makes more sense to use `has_one` with Rails' singular associations and `has_many` with Rails' plural associations.
+
+#### `has_one`
+
+In the example below, assume
+
+```ruby
+class Book < ActiveRecord::Base
+  belongs_to :author
+end
+```
+
+This presenter :point_down: selects the title of every book as well as its author's name:
+
+```ruby
+presenter = PluckMap[Book].define do
+  title
+  has_one :author do
+    name
+  end
+end
+```
+
+(We can also write it using block variables, if that's easier to read.)
+
+```ruby
+presenter = PluckMap[Book].define do |book|
+  book.title
+  book.has_one :author do |author|
+    author.name
+  end
+end
+```
+
+Attributes defined for a relationship support all the same features as [attributes defined at the root level](#defining-attributes-to-present).
+
+
+#### `has_many`
+
+We can present the reverse of the above example with `has_many`. This example will select a list of authors and, for each, a list of the books they wrote:
+
+```ruby
+presenter = PluckMap[Author].define do
+  name
+  has_many :books do
+    title
+  end
+end
+```
+
+#### scopes
+
+An optional second argument to both `has_one` and `has_many` is a scope block that you can use to modify the query that would select the associated records. You can use any of ActiveRecord's standard [querying methods](https://guides.rubyonrails.org/active_record_querying.html) inside the scope block.
+
+In this example, we've altered our last presenter to ensure that books are listed alphabetically:
+
+```ruby
+presenter = PluckMap[Author].define do
+  name
+  has_many :books, -> { order(title: :asc) } do
+    title
+  end
+end
+```
+
 
 ### Presenting Records
 
@@ -299,9 +374,11 @@ The gem's only runtime requirement is:
 
 It supports these databases out of the box:
 
- - PostgreSQL
- - MySQL
- - SQLite
+ - PostgreSQL 9.4+
+ - MySQL 5.7.22+
+ - SQLite 3.10.0+
+
+(Note: the versions given above are when certain JSON aggregate functions were introduced in each supported database. `PluckMap`'s core behavior will work with earlier versions of the database above but certain features like optimizations to `to_json` and relationships require the specified versions.)
 
 
 

data/lib/pluck_map/association_scope.rb

@@ -0,0 +1,102 @@
+require "active_record"
+
+# ActiveRecord::Associations::AssociationScope assumes that values
+# for Owner's fields will be concrete values that need to be type-cast.
+#
+# But our AbstractOwner returns field references (Arel::Attributes::Attribute)
+# and we need them to bypass type-casting.
+#
+module PluckMap
+  module AssociationScope
+    def self.[](version)
+      const_get "Rails#{version.to_s.delete(".")}"
+    end
+
+    def self.create
+      case ActiveRecord.version.segments.take(2)
+      when [4,2] then self[4.2].create
+      when [5,0] then self[5.0].create
+      else self::Current.create
+      end
+    end
+
+
+    # Rails 5.1+
+    class Current < ActiveRecord::Associations::AssociationScope
+      def apply_scope(scope, table, key, value)
+        if value.is_a?(Arel::Attributes::Attribute)
+          scope.where!(table[key].eq(value))
+        else
+          super
+        end
+      end
+
+      def scope(association)
+        if ActiveRecord.version.version < "5.2"
+          super(association, association.reflection.active_record.connection)
+        else
+          super
+        end
+      end
+    end
+
+
+    # In Rails 5.0, `apply_scope` isn't extracted from `last_chain_scope`
+    # and `next_chain_scope` so we have to override the entire methods to
+    # extract `apply_scope` and bypass type-casting.
+    #
+    # Refer to https://github.com/rails/rails/blob/v5.0.7.2/activerecord/lib/active_record/associations/association_scope.rb#L61-L94
+    #
+    class Rails50 < Current
+      def last_chain_scope(scope, table, reflection, owner, association_klass)
+        join_keys = reflection.join_keys(association_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        value = transform_value(owner[foreign_key])
+        scope = apply_scope(scope, table, key, value)
+
+        if reflection.type
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+        end
+
+        scope
+      end
+
+      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(association_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        constraint = table[key].eq(foreign_table[foreign_key])
+
+        if reflection.type
+          value = transform_value(next_reflection.klass.base_class.name)
+          scope = apply_scope(scope, table, reflection.type, value)
+        end
+
+        scope = scope.joins(join(foreign_table, constraint))
+      end
+
+      def apply_scope(scope, table, key, value)
+        if value.is_a?(Arel::Attributes::Attribute)
+          scope.where(table[key].eq(value))
+        else
+          scope.where(table.name => { key => value })
+        end
+      end
+    end
+
+
+    class Rails42 < Current
+      def bind(_, _, _, value, _)
+        if value.is_a?(Arel::Attributes::Attribute)
+          value
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/pluck_map/attribute.rb

@@ -14,16 +14,14 @@ module PluckMap
         @value = options[:value]
         @selects = []
       else
-        raise ArgumentError, "You must select at least one column" if selects.empty?
+        raise ArgumentError, "You must select at least one column" if @selects.empty?
         raise ArgumentError, "You must define a block if you are going to select " <<
-          "more than one expression from the database" if selects.length > 1 && !block
+          "more than one expression from the database" if @selects.length > 1 && !@block
 
-        @selects = @selects.map do |select|
+        @selects.each do |select|
           if select.is_a?(String) && !select.is_a?(Arel::Nodes::SqlLiteral)
-            puts "DEPRECATION WARNING: Passing raw SQL as a String to :select is deprecated. Known-safe values can be passed by wrapping them in Arel.sql()."
-            Arel.sql(select)
-          else
-            select
+            raise ArgumentError, "#{select.inspect} is not a valid value for :select. " <<
+              "If a string of raw SQL is safe, wrap it in Arel.sql()."
           end
         end
       end
@@ -33,10 +31,21 @@ module PluckMap
       block.call(*object)
     end
 
+    def value?
+      defined?(@value)
+    end
+
     def will_map?
       !block.nil?
     end
 
+    def nested?
+      false
+    end
+
+    def preload!(results)
+    end
+
     # When the PluckMapPresenter performs the query, it will
     # receive an array of rows. Each row will itself be an
     # array of values.
@@ -44,18 +53,22 @@ module PluckMap
     # This method constructs a Ruby expression that will
     # extract the appropriate values from each row that
     # correspond to this Attribute.
-    def to_ruby(selects = nil)
-      if selects
-        puts "DEPRECATION WARNING: PluckMap::Attribute#to_ruby no longer requires an argument. Replace `attribute.to_ruby(keys)` with `attribute.to_ruby`."
-      end
-
-      return @value.inspect if defined?(@value)
+    def to_ruby
+      return @value.inspect if value?
       return "values[#{indexes[0]}]" if indexes.length == 1 && !block
       ruby = "values.values_at(#{indexes.join(", ")})"
       ruby = "invoke(:\"#{id}\", #{ruby})" if block
       ruby
     end
 
+    def exec(values)
+      return @value if value?
+      return values[indexes[0]] if indexes.length == 1 && !block
+      _values = values.values_at(*indexes)
+      _values = apply(_values) if block
+      _values
+    end
+
 
 
     def values

data/lib/pluck_map/attribute_builder.rb

@@ -1,5 +1,6 @@
 require "pluck_map/attribute"
 require "pluck_map/attributes"
+require "pluck_map/relationships"
 
 module PluckMap
   class AttributeBuilder < BasicObject
@@ -12,7 +13,7 @@ module PluckMap
       else
         builder.instance_eval(&block)
       end
-      Attributes.new(attributes)
+      Attributes.new(attributes, model)
     end
 
     def initialize(attributes, model)
@@ -27,5 +28,19 @@ module PluckMap
       :attribute_added
     end
 
+    def has_many(name, *args, &block)
+      options = args.extract_options!
+      options[:scope_block] = args.first unless args.empty?
+      @attributes.push Relationships.many(@model, name, block, options)
+      :relationship_added
+    end
+
+    def has_one(name, *args, &block)
+      options = args.extract_options!
+      options[:scope_block] = args.first unless args.empty?
+      @attributes.push Relationships.one(@model, name, block, options)
+      :relationship_added
+    end
+
   end
 end

data/lib/pluck_map/attributes.rb

@@ -2,9 +2,10 @@ module PluckMap
   class Attributes
     include Enumerable
 
-    attr_reader :selects
+    attr_reader :selects, :model
 
-    def initialize(attributes)
+    def initialize(attributes, model)
+      @model = model
       @_attributes = attributes.freeze
       @_attributes_by_id = {}
       @selects = []
@@ -40,12 +41,23 @@ module PluckMap
       _attributes_by_id
     end
 
+    def to_json_array
+      PluckMap::BuildJsonArray.new(*selects.map do |select|
+        select = model.arel_table[select] if select.is_a?(Symbol)
+        select
+      end)
+    end
+
 
 
     def will_map?
       _attributes.any?(&:will_map?)
     end
 
+    def nested?
+      _attributes.any?(&:nested?)
+    end
+
 
 
     def ==(other)

data/lib/pluck_map/errors.rb

@@ -0,0 +1,4 @@
+module PluckMap
+  class UnsupportedAttributeError < ArgumentError
+  end
+end

data/lib/pluck_map/nodes.rb

@@ -0,0 +1,40 @@
+require "arel"
+
+module PluckMap
+  class BuildJsonObject < Arel::Nodes::Node
+    include Arel::AliasPredication
+
+    attr_reader :args
+
+    def initialize(*args)
+      @args = args
+    end
+  end
+
+  class BuildJsonArray < Arel::Nodes::Node
+    include Arel::AliasPredication
+
+    attr_reader :args
+
+    def initialize(*args)
+      @args = args
+    end
+  end
+
+  class JsonArrayAggregate < Arel::Nodes::Node
+    attr_reader :arg
+
+    def initialize(arg)
+      @arg = arg
+    end
+  end
+
+  class JsonSubqueryAggregate < Arel::Nodes::Node
+    attr_reader :scope, :select
+
+    def initialize(scope, select)
+      @scope = scope
+      @select = select
+    end
+  end
+end

data/lib/pluck_map/presenter.rb

@@ -1,5 +1,8 @@
 require "pluck_map/attribute_builder"
+require "pluck_map/errors"
+require "pluck_map/nodes"
 require "pluck_map/presenters"
+require "pluck_map/visitors"
 require "active_record"
 
 module PluckMap
@@ -8,38 +11,24 @@ module PluckMap
 
     attr_reader :model, :attributes
 
-    def initialize(model = nil, attributes = nil, &block)
-      if block_given?
-        puts "DEPRECATION WARNING: `PluckMap::Presenter.new` will be deprecated. Use `PluckMap[Model].define` instead."
-        @attributes = PluckMap::AttributeBuilder.build(model: nil, &block)
-      else
-        @model = model
-        @attributes = attributes
-      end
-
-      if respond_to?(:define_presenters!, true)
-        puts "DEPRECATION WARNING: `define_presenters!` is deprecated; instead mix in a module that implements your presenter method (e.g. `to_h`). Optionally have the method redefine itself the first time it is called."
-        # because overridden `define_presenters!` will probably call `super`
-        PluckMap::Presenter.class_eval 'protected def define_presenters!; end'
-        define_presenters!
-      end
-    end
-
-    def no_map?
-      puts "DEPRECATION WARNING: `PluckMap::Presenter#no_map?` is deprecated. You can replace it with `!attributes.will_map?`"
-      !attributes.will_map?
+    def initialize(model, attributes)
+      @model = model
+      @attributes = attributes
     end
 
   protected
 
     def pluck(query)
-      unless model.nil? || query.model <= model
+      if query.model != model
         raise ArgumentError, "Query for #{query.model} but #{model} expected"
       end
 
       # puts "\e[95m#{query.select(*selects).to_sql}\e[0m"
       results = benchmark("pluck(#{query.table_name})") { query.pluck(*selects) }
       return results unless block_given?
+      attributes.each do |attribute|
+        attribute.preload!(results)
+      end
       benchmark("map(#{query.table_name})") { yield results }
     end
 
@@ -89,10 +78,5 @@ module PluckMap
       attributes.by_id
     end
 
-    def keys
-      puts "DEPRECATION WARNING: PluckMap::Presenter#keys is deprecated; use #selects instead"
-      selects
-    end
-
   end
 end

data/lib/pluck_map/presenters/to_csv.rb

@@ -1,7 +1,13 @@
+require "pluck_map/errors"
+
 module PluckMap
   module CsvPresenter
 
     def to_csv(query)
+      if attributes.nested?
+        raise PluckMap::UnsupportedAttributeError, "to_csv can not be used to present nested attributes"
+      end
+
       define_to_csv!
       to_csv(query)
     end

data/lib/pluck_map/presenters/to_json.rb

@@ -4,11 +4,77 @@ module PluckMap
   module JsonPresenter
 
     def to_json(query, json: default_json, **)
-      json.dump(to_h(query))
+      if attributes.will_map?
+        to_json__default(query, json: json)
+      else
+        to_json__optimized(query)
+      end
     end
 
   private
 
+    def to_json__default(query, json: default_json, **)
+      json.dump(to_h(query))
+    end
+
+    def to_json__optimized(query, **)
+      define_to_json__optimized!
+      to_json__optimized(query)
+    end
+
+    def define_to_json__optimized!
+      sql = compile(to_json_object(attributes).as("object"))
+
+      ruby = <<-RUBY
+      private def to_json__optimized(query, **)
+        sql = wrap_aggregate(query.select(Arel.sql(#{sql.inspect})))
+        query.connection.select_value(sql)
+      end
+      RUBY
+      # puts "\e[34m#{ruby}\e[0m" # <-- helps debugging PluckMapPresenter
+      class_eval ruby, __FILE__, __LINE__ - ruby.length
+    end
+
+    def to_json_object(attributes)
+      args = []
+      attributes.each do |attribute|
+        args << Arel::Nodes::Quoted.new(attribute.name)
+        args << send(:"prepare_#{attribute.class.name.gsub("::", "_")}", attribute)
+      end
+      PluckMap::BuildJsonObject.new(*args)
+    end
+
+    def prepare_PluckMap_Attribute(attribute)
+      return Arel::Nodes::Quoted.new(attribute.value) if attribute.value?
+      arg = attribute.selects[0]
+      arg = attribute.model.arel_table[arg] if arg.is_a?(Symbol)
+      arg
+    end
+
+    def prepare_PluckMap_Relationships_Many(attribute)
+      PluckMap::JsonSubqueryAggregate.new(attribute.scope, to_json_object(attribute.attributes))
+    end
+
+    def prepare_PluckMap_Relationships_One(attribute)
+      Arel.sql("(#{attribute.scope.select(to_json_object(attribute.attributes)).to_sql})")
+    end
+
+    def wrap_aggregate(subquery)
+      "SELECT #{compile(aggregate(Arel.sql("d.object")))} FROM (#{subquery.to_sql}) AS d"
+    end
+
+    def aggregate(object)
+      PluckMap::JsonArrayAggregate.new(object)
+    end
+
+    def compile(node)
+      visitor.compile(node)
+    end
+
+    def visitor
+      model.connection.visitor
+    end
+
     def default_json
       if defined?(MultiJson)
         MultiJson

data/lib/pluck_map/relationships.rb

@@ -0,0 +1,85 @@
+require "pluck_map/association_scope"
+require "pluck_map/relationships/base"
+require "pluck_map/relationships/many"
+require "pluck_map/relationships/one"
+require "pluck_map/relationships/polymorphic_one"
+
+module PluckMap
+  module Relationships
+    class << self
+
+      def one(model, name, block, options)
+        reflection = reflection_for(model, name)
+        if reflection.polymorphic?
+          Relationships::PolymorphicOne.new(name, reflection, block, options)
+        else
+          Relationships::One.new(name, scope_for_reflection(reflection), block, options)
+        end
+      end
+
+      def many(model, name, block, options)
+        Relationships::Many.new(name, scope(model, name), block, options)
+      end
+
+    private
+
+      def scope(model, name)
+        scope_for_reflection(reflection_for(model, name))
+      end
+
+      def scope_for_reflection(reflection)
+        scope_for(association_for(reflection))
+      end
+
+      def reflection_for(model, name)
+        # Use `_reflections.fetch(name)` instead of `reflect_on_association(name)`
+        # because they have different behavior when it comes to HasAndBelongsToMany
+        # associations.
+        #
+        # `reflect_on_association` will return a HasAndBelongsToManyReflection
+        # while `_reflections.fetch(name)` will return a ThroughReflection that
+        # wraps a HasAndBelongsToManyReflection.
+        #
+        # ActiveRecord::Associations::AssociationScope expects the latter.
+        #
+        model._reflections.fetch(name.to_s) do
+          raise ArgumentError, "#{name} is not an association on #{model}"
+        end
+      end
+
+      def association_for(reflection)
+        owner = AbstractOwner.new(reflection)
+        reflection.association_class.new(owner, reflection)
+      end
+
+      def scope_for(association)
+        AssociationScope.create.scope(association)
+      end
+
+      # ActiveRecord constructs an Association from a Reflection and an
+      # Owner. It expects Owner to be an instance of an ActiveRecord object
+      # and uses `[]` to access specific values for fields on the record.
+      #
+      #    e.g. WHERE books.author_id = 7
+      #
+      # We want to create a subquery that will reference those fields
+      # but not their specific values.
+      #
+      #    e.g. WHERE books.author_id = authors.id
+      #
+      # So we create an object that serves the purpose of Owner but returns
+      # appropriate selectors.
+      #
+      AbstractOwner = Struct.new(:reflection) do
+        def class
+          reflection.active_record
+        end
+
+        def [](value)
+          self.class.arel_table[value]
+        end
+      end
+
+    end
+  end
+end

data/lib/pluck_map/relationships/base.rb

@@ -0,0 +1,39 @@
+require "pluck_map/attribute"
+
+module PluckMap
+  module Relationships
+    class Base < Attribute
+      attr_reader :attributes, :scope
+
+      def initialize(attribute_name, scope, block, options)
+        @scope = scope
+        @attributes = AttributeBuilder.build(model: scope.klass, &block)
+        @scope = @scope.instance_exec(&options[:scope_block]) if options[:scope_block]
+        options = options.slice(:as).merge(
+          select: build_select,
+          map: build_map)
+
+        super(attribute_name, scope.klass, options)
+      end
+
+      def will_map?
+        attributes.any?(&:will_map?)
+      end
+
+      def nested?
+        true
+      end
+
+    protected
+
+      def build_select
+        raise NotImplementedError
+      end
+
+      def build_map
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/pluck_map/relationships/many.rb

@@ -0,0 +1,34 @@
+require "active_record/version"
+require "pluck_map/attribute"
+
+module PluckMap
+  module Relationships
+    class Many < Base
+    protected
+
+      def build_select
+        node = PluckMap::JsonSubqueryAggregate.new(scope, attributes.to_json_array)
+
+        # On Rails 4.2, `pluck` can't accept Arel nodes
+        if ActiveRecord.version.segments.take(2) == [4,2]
+          Arel.sql(scope.connection.visitor.compile(node))
+        else
+          node
+        end
+      end
+
+      def build_map
+        lambda do |results|
+          return [] if results.nil?
+          results = JSON.parse(results) if results.is_a?(String)
+          results.map do |values|
+            attributes.each_with_object({}) do |attribute, hash|
+              hash[attribute.name] = attribute.exec(values)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pluck_map/relationships/one.rb

@@ -0,0 +1,24 @@
+require "pluck_map/attribute"
+
+module PluckMap
+  module Relationships
+    class One < Base
+    protected
+
+      def build_select
+        Arel.sql("(#{scope.select(attributes.to_json_array).to_sql})")
+      end
+
+      def build_map
+        lambda do |values|
+          return nil if values.nil?
+          values = JSON.parse(values) if values.is_a?(String)
+          attributes.each_with_object({}) do |attribute, hash|
+            hash[attribute.name] = attribute.exec(values)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pluck_map/relationships/polymorphic_one.rb

@@ -0,0 +1,58 @@
+require "pluck_map/attribute"
+
+module PluckMap
+  module Relationships
+    class PolymorphicOne < Attribute
+
+      def initialize(attribute_name, reflection, block, options)
+        @reflection = reflection
+        @attributes_block = block
+        @scope_block = options[:scope_block]
+
+        options = options.slice(:as).merge(
+          select: [ reflection.foreign_type.to_sym, reflection.foreign_key.to_sym ],
+          map: ->(*args) { @preloads[args] })
+
+        super(attribute_name, reflection.active_record, options)
+      end
+
+      def nested?
+        true
+      end
+
+      def preload!(results)
+        ids_by_type = Hash.new { |hash, key| hash[key] = [] }
+
+        results.each do |values|
+          type, id = values.values_at(*indexes)
+          ids_by_type[type].push(id)
+        end
+
+        @preloads = Hash.new
+        ids_by_type.each do |type, ids|
+          klass = type.constantize
+          scope = klass.where(id: ids)
+          scope = scope.instance_exec(&@scope_block) if @scope_block
+
+          presenter = PluckMap[klass].define do |q|
+            q.__id select: klass.primary_key.to_sym
+
+            if @attributes_block.arity == 1
+              @attributes_block.call(q)
+            else
+              q.instance_eval(&@attributes_block)
+            end
+          end
+
+          presenter.to_h(scope).each do |h|
+            id = h.delete(:__id)
+            @preloads[[type, id]] = h
+          end
+        end
+
+        nil
+      end
+
+    end
+  end
+end

data/lib/pluck_map/version.rb

@@ -1,3 +1,3 @@
 module PluckMapPresenter
-  VERSION = "0.6.2"
+  VERSION = "1.0.0.rc1"
 end

data/lib/pluck_map/visitors.rb

@@ -0,0 +1,4 @@
+require "arel"
+require "pluck_map/visitors/sqlite"
+require "pluck_map/visitors/postgresql"
+require "pluck_map/visitors/mysql"

data/lib/pluck_map/visitors/mysql.rb

@@ -0,0 +1,36 @@
+require "arel/visitors/mysql"
+
+module Arel
+  module Visitors
+    class MySQL
+      def visit_PluckMap_BuildJsonObject(o, collector)
+        collector << "json_object("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_BuildJsonArray(o, collector)
+        collector << "json_array("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_JsonArrayAggregate(o, collector)
+        collector << "json_arrayagg("
+        visit o.arg, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_JsonSubqueryAggregate(o, collector)
+        interior = compile(o.select)
+        if o.scope.order_values.present?
+          interior = "#{interior} ORDER BY #{compile(o.scope.order_values)}"
+        end
+        interior = "CAST(CONCAT('[',GROUP_CONCAT(#{interior}),']') AS JSON)"
+        sql = o.scope.reorder(nil).select(Arel.sql(interior)).to_sql
+
+        collector << "COALESCE((#{sql}), json_array())"
+      end
+    end
+  end
+end

data/lib/pluck_map/visitors/postgresql.rb

@@ -0,0 +1,30 @@
+require "arel/visitors/postgresql"
+
+module Arel
+  module Visitors
+    class PostgreSQL
+      def visit_PluckMap_BuildJsonObject(o, collector)
+        collector << "json_build_object("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_BuildJsonArray(o, collector)
+        collector << "json_build_array("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_JsonArrayAggregate(o, collector)
+        collector << "json_agg("
+        visit o.arg, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_JsonSubqueryAggregate(o, collector)
+        sql = o.scope.select(o.select.as("object")).to_sql
+        collector << "COALESCE((SELECT json_agg(d.object) FROM (#{sql}) AS d), json_build_array())"
+      end
+    end
+  end
+end

data/lib/pluck_map/visitors/sqlite.rb

@@ -0,0 +1,30 @@
+require "arel/visitors/sqlite"
+
+module Arel
+  module Visitors
+    class SQLite
+      def visit_PluckMap_BuildJsonObject(o, collector)
+        collector << "json_object("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_BuildJsonArray(o, collector)
+        collector << "json_array("
+        visit o.args, collector
+        collector << ")"
+      end
+
+      def visit_PluckMap_JsonArrayAggregate(o, collector)
+        collector << "json_group_array(json("
+        visit o.arg, collector
+        collector << "))"
+      end
+
+      def visit_PluckMap_JsonSubqueryAggregate(o, collector)
+        sql = o.scope.select(o.select.as("object")).to_sql
+        collector << "COALESCE((SELECT json_group_array(json(d.object)) FROM (#{sql}) AS d), json_array())"
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pluck_map
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-14 00:00:00.000000000 Z
+date: 2019-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -257,17 +257,29 @@ files:
 - gemfiles/rails_5.2.gemfile
 - gemfiles/rails_edge.gemfile
 - lib/pluck_map.rb
+- lib/pluck_map/association_scope.rb
 - lib/pluck_map/attribute.rb
 - lib/pluck_map/attribute_builder.rb
 - lib/pluck_map/attributes.rb
+- lib/pluck_map/errors.rb
 - lib/pluck_map/model_context.rb
+- lib/pluck_map/nodes.rb
 - lib/pluck_map/null_logger.rb
 - lib/pluck_map/presenter.rb
 - lib/pluck_map/presenters.rb
 - lib/pluck_map/presenters/to_csv.rb
 - lib/pluck_map/presenters/to_h.rb
 - lib/pluck_map/presenters/to_json.rb
+- lib/pluck_map/relationships.rb
+- lib/pluck_map/relationships/base.rb
+- lib/pluck_map/relationships/many.rb
+- lib/pluck_map/relationships/one.rb
+- lib/pluck_map/relationships/polymorphic_one.rb
 - lib/pluck_map/version.rb
+- lib/pluck_map/visitors.rb
+- lib/pluck_map/visitors/mysql.rb
+- lib/pluck_map/visitors/postgresql.rb
+- lib/pluck_map/visitors/sqlite.rb
 - pluck_map.gemspec
 homepage: https://github.com/boblail/pluck_map
 licenses: []
@@ -283,9 +295,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6