pluck_map 0.6.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6713a4fb63be352fb7c8d54bbbdb7a559fc4b523093f3cff0a72b9507803a8e
-  data.tar.gz: e7f9e9caea6745daeb1beab73c711fd87656309fd3221422ad027072d6fcd8d7
+  metadata.gz: 597612beb6033e9f03ae69a121aa0a91eab830e400917e3dc8e1f4b42052545b
+  data.tar.gz: 0bac2743a30f9795a6bfa572ef2faf7ee230aea78b75b9d0b0ac41399fd37077
 SHA512:
-  metadata.gz: ca03d1e1f7e82934ee018c93ac980b7f35c8d9805782de196cb1941b36992880ef19f193d8d9055ac03a3999cf58168503e65ccd74fd10a59d806178c2d8950f
-  data.tar.gz: 48822bd995380e8a97e5166c94f890b010823b55227884c66f06e6d4d36b6baf22c9b577aa3acf9670d2cca186c4dac3ccb6ee165b8c27e7861f89d31c4ba5ce
+  metadata.gz: 5dab317224c87b728585ebfd45267be0780854fe0a383b31cabcf88781c58900845af6d3dcf760f2beb35199b58fc7636f3a55dad125ead09579414cdd867fa2
+  data.tar.gz: 2cc8bfb68996ca3a350a0cd3324e9d56309485975622b72c0a13584c523f47a7bf1f90ca59b16fee0afc145c4283da12cf3504f04e2b8cfb71c43b42eb9ba26a

data/.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
-rvm: 2.5.5
+rvm: 2.6.3
+
+# we need MySQL 5.7+ to support JSON aggregation
+dist: xenial
 
-# Rails 6 requires Postgres 9.3+
 addons:
-  postgresql: "9.3"
+  # Rails 6 requires Postgres 9.3+
+  # We need Postgres 9.4+ to support JSON aggregation
+  postgresql: "9.4"
 
 services:
   - postgresql
@@ -17,6 +21,7 @@ matrix:
   - gemfile: gemfiles/rails_5.0.gemfile
   - gemfile: gemfiles/rails_5.1.gemfile
   - gemfile: gemfiles/rails_5.2.gemfile
+  - gemfile: gemfiles/rails_6.0.gemfile
   - gemfile: gemfiles/rails_edge.gemfile
   allow_failures:
   - gemfile: gemfiles/rails_edge.gemfile

data/Appraisals

@@ -19,6 +19,11 @@ appraise "rails-5.2" do
   gem "sqlite3", "~> 1.3.6"
 end
 
+appraise "rails-6.0" do
+  gem "activerecord", "~> 6.0.0"
+  gem "sqlite3", "~> 1.4.0"
+end
+
 appraise "rails-edge" do
   gem "rails", git: "https://github.com/rails/rails.git", branch: "master", require: "activerecord"
   gem "sqlite3", "~> 1.4.0"

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## Unreleased
+
+* BREAKING: `define` returns a subclass of `PluckMap::Presenter` instead of an instance (@boblail)
+* FEATURE: `define` also creates structs to correspond to each presenter (@boblail)
+
+## v1.0.0 (2019 Jul 17)
+
+* FIX: Respect default_scopes for relationships (@boblail)
+
+## v1.0.0.rc2 (2019 Jun 17)
+
+* FEATURE: Add structured attributes to allow nesting attributes as a hash (@kobsy)
+
+## v1.0.0.rc1 (2019 May 12)
+
+* 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.2 (2019 Jun 13)
 
 * FIX: Allow presenting a subclass of the presenter's model (@kobsy)

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,93 @@ presenter = PluckMap[Person].define do
 end
 ```
 
+### Structured attributes
+
+You can also nest attributes by passing a block to the attribute method:
+
+```ruby
+presenter = PluckMap[Person].define do
+  parent do
+    id select: :parent_id
+    type "Parent"
+  end
+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 +387,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/gemfiles/rails_6.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.0.0"
+gem "sqlite3", "~> 1.4.0"
+
+gemspec path: "../"

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,7 @@
 require "pluck_map/attribute"
+require "pluck_map/structured_attribute"
 require "pluck_map/attributes"
+require "pluck_map/relationships"
 
 module PluckMap
   class AttributeBuilder < BasicObject
@@ -12,7 +14,7 @@ module PluckMap
       else
         builder.instance_eval(&block)
       end
-      Attributes.new(attributes)
+      Attributes.new(attributes, model)
     end
 
     def initialize(attributes, model)
@@ -20,12 +22,27 @@ module PluckMap
       @model = model
     end
 
-    def method_missing(attribute_name, *args)
+    def method_missing(attribute_name, *args, &block)
       options = args.extract_options!
       options[:value] = args.first unless args.empty?
-      @attributes.push Attribute.new(attribute_name, @model, options)
+      @attributes.push block.nil? ? Attribute.new(attribute_name, @model, options) :
+        StructuredAttribute.new(attribute_name, @model, block, options)
       :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 = []
@@ -36,16 +37,31 @@ module PluckMap
 
 
 
+    def ids
+      _attributes_by_id.keys
+    end
+
     def by_id
       _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/model_context.rb

@@ -1,4 +1,5 @@
 require "pluck_map/presenter"
+require "pluck_map/struct"
 
 module PluckMap
   class ModelContext
@@ -8,7 +9,27 @@ module PluckMap
 
     def define(&block)
       attributes = PluckMap::AttributeBuilder.build(model: @model, &block)
-      PluckMap::Presenter.new(@model, attributes)
+      define_class!(@model, attributes)
+    end
+
+  private
+
+    def define_class!(model, attributes)
+      # Create a new subclass of PluckMap::Presenter
+      klass = Class.new(PluckMap::Presenter)
+
+      # Partially apply initialize with the parameters passed to this method
+      klass.define_method(:initialize) do |query|
+        super(model, attributes, query)
+      end
+
+      # Generate a Struct constant in the namespace of the new subclass
+      struct = ::Struct.new(*attributes.ids, keyword_init: true)
+      struct.extend PluckMap::Struct::ClassMethods
+      struct.instance_variable_set :@presenter, klass
+      klass.const_set :Struct, struct
+
+      klass
     end
   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,45 +1,35 @@
 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
   class Presenter
     include CsvPresenter, HashPresenter, JsonPresenter
 
-    attr_reader :model, :attributes
+    attr_reader :model, :attributes, :query
 
-    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!
+    def initialize(model, attributes, query)
+      unless query.model <= model
+        raise ArgumentError, "Query for #{query.model} but #{model} expected"
       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?
+      @model = model
+      @attributes = attributes
+      @query = query
     end
 
   protected
 
-    def pluck(query)
-      unless model.nil? || query.model <= model
-        raise ArgumentError, "Query for #{query.model} but #{model} expected"
-      end
-
+    def pluck
       # 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
 
@@ -81,6 +71,7 @@ module PluckMap
 
         # On Rails 4.2, `pluck` can't accept Arel nodes
         select = Arel.sql(select.to_sql) if ActiveRecord.version.segments.take(2) == [4,2] && select.respond_to?(:to_sql)
+
         select
       }
     end
@@ -89,10 +80,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,9 +1,21 @@
+require "pluck_map/errors"
+
 module PluckMap
   module CsvPresenter
 
-    def to_csv(query)
+    def self.included(base)
+      def base.to_csv(query, **kargs)
+        new(query).to_csv(**kargs)
+      end
+    end
+
+    def to_csv
+      if attributes.nested?
+        raise PluckMap::UnsupportedAttributeError, "to_csv can not be used to present nested attributes"
+      end
+
       define_to_csv!
-      to_csv(query)
+      to_csv
     end
 
     private def define_to_csv!
@@ -11,8 +23,8 @@ module PluckMap
 
       headers = CSV.generate_line(attributes.map(&:name))
       ruby = <<-RUBY
-      def to_csv(query)
-        pluck(query) do |results|
+      def to_csv
+        pluck do |results|
           rows = [#{headers.inspect}]
           results.each_with_object(rows) do |values, rows|
             values = Array(values)

data/lib/pluck_map/presenters/to_h.rb

@@ -1,15 +1,21 @@
 module PluckMap
   module HashPresenter
 
-    def to_h(query)
+    def self.included(base)
+      def base.to_h(query, **kargs)
+        new(query).to_h(**kargs)
+      end
+    end
+
+    def to_h
       define_to_h!
-      to_h(query)
+      to_h
     end
 
     private def define_to_h!
       ruby = <<-RUBY
-      def to_h(query)
-        pluck(query) do |results|
+      def to_h
+        pluck do |results|
           results.map { |values| values = Array(values); { #{attributes.map { |attribute| "#{attribute.name.inspect} => #{attribute.to_ruby}" }.join(", ")} } }
         end
       end

data/lib/pluck_map/presenters/to_json.rb

@@ -3,12 +3,88 @@ require "json"
 module PluckMap
   module JsonPresenter
 
-    def to_json(query, json: default_json, **)
-      json.dump(to_h(query))
+    def self.included(base)
+      def base.to_json(query, **kargs)
+        new(query).to_json(**kargs)
+      end
+    end
+
+    def to_json(json: default_json, **)
+      if attributes.will_map?
+        to_json__default(json: json)
+      else
+        to_json__optimized
+      end
     end
 
   private
 
+    def to_json__default(json: default_json, **)
+      json.dump(to_h)
+    end
+
+    def to_json__optimized(**)
+      define_to_json__optimized!
+      to_json__optimized
+    end
+
+    def define_to_json__optimized!
+      sql = compile(to_json_object(attributes).as("object"))
+
+      ruby = <<-RUBY
+      private def to_json__optimized(**)
+        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_StructuredAttribute(attribute)
+      to_json_object(attribute.attributes)
+    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,89 @@
+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)
+        default_scope_for(association).merge(AssociationScope.create.scope(association))
+      end
+
+      def default_scope_for(association)
+        association.klass.all
+      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,26 @@
+require "pluck_map/structured_attribute"
+
+module PluckMap
+  module Relationships
+    class Base < StructuredAttribute
+      attr_reader :scope
+
+      def initialize(attribute_name, scope, block, options)
+        @scope = scope
+        @scope = @scope.instance_exec(&options[:scope_block]) if options[:scope_block]
+        super(attribute_name, scope.klass, block, options)
+      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/struct.rb

@@ -0,0 +1,13 @@
+module PluckMap
+  module Struct
+    module ClassMethods
+      def presenter
+        @presenter || superclass.presenter
+      end
+
+      def load(relation)
+        presenter.to_h(relation).map { |values| new(**values) }
+      end
+    end
+  end
+end

data/lib/pluck_map/structured_attribute.rb

@@ -0,0 +1,37 @@
+require "pluck_map/attribute"
+
+module PluckMap
+  class StructuredAttribute < Attribute
+    attr_reader :attributes
+
+    def initialize(attribute_name, model, block, options={})
+      @attributes = AttributeBuilder.build(model: model, &block)
+      options = options.slice(:as).merge(select: build_select, map: build_map)
+      super(attribute_name, model, options)
+    end
+
+    def will_map?
+      attributes.any?(&:will_map?)
+    end
+
+    def nested?
+      true
+    end
+
+  protected
+
+    def build_select
+      attributes.selects
+    end
+
+    def build_map
+      lambda do |*values|
+        return nil if values.none?
+        attributes.each_with_object({}) do |attribute, hash|
+          hash[attribute.name] = attribute.exec(values)
+        end
+      end
+    end
+
+  end
+end

data/lib/pluck_map/version.rb

@@ -1,3 +1,3 @@
 module PluckMapPresenter
-  VERSION = "0.6.2"
+  VERSION = "2.0.0"
 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

data/pluck_map.gemspec

@@ -17,11 +17,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  # uses `keyword_init` argument of `Struct.new`
+  spec.required_ruby_version = '>= 2.5.0'
+
   spec.add_dependency "activerecord", ">= 4.2"
 
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest-reporters"
   spec.add_development_dependency "minitest-reporters-turn_reporter"
   spec.add_development_dependency "sqlite3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pluck_map
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-14 00:00:00.000000000 Z
+date: 2020-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,16 +56,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -255,19 +255,34 @@ files:
 - gemfiles/rails_5.0.gemfile
 - gemfiles/rails_5.1.gemfile
 - gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.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/struct.rb
+- lib/pluck_map/structured_attribute.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: []
@@ -280,15 +295,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A DSL for presenting ActiveRecord::Relations without instantiating ActiveRecord