active_record_extended 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9600653726c77cad5b6e0a90c1f5a55213c95804a3b094c1595aa085127f2605
-  data.tar.gz: 0a7204abdd56e9d92c6b304d42d79b7270feb966aed55cc122e2c2ad68d91dab
+  metadata.gz: b524c24c37e0b6f7449d70e5030b893119b98dec6646b905c3a307c9a671c7f1
+  data.tar.gz: 18cb235fba334ebfaa752b92ad024117f686176b0e9107af6333e317a333c70f
 SHA512:
-  metadata.gz: '008286c5485c0e14d8fd113ac12c78f2079f572ad5d99bf4eee9c8c3fa16c58948c496aa79436718098a120d3481aa832a2d9509f89beb7ee7733e2d96754ae3'
-  data.tar.gz: e239092f0511f1c75f2eca0a0aed42f193d14a6f4c490dc6549c87c19c231b671d5a3316be6dcaea0641d6c633f33f93ae8618a43f7b5314d1d97ad2abda7fd3
+  metadata.gz: 78539255c169c26a1d6bab3968a2eed038d8391d532f97d55dabf7a7c071cddf4eee1424586021cd7b790db4abf042cf0617ac69ede670caeb9cde55a23125a4
+  data.tar.gz: 798ea355e5ebe213735db1552e7328d05c855c45800c941d4c5400a812b6d71f169ff52a48c0b9e6bf678d2dcf83ac1c7308a172b120caf9f83a240b0025e599

data/README.md

@@ -46,7 +46,6 @@ The only problem is that this has created a wild west of environments of sorts.
 
 Active Record Extended is essentially providing users with the other half of Postgreses querying abilities. Due to Rails/ActiveRecord/Arel being designed to be DB agnostic, there are a lot of left out features; Either by choice or the simple lack of supporting API's for other databases. However some features are not exactly PG explicit. Some are just helper methods to express an idea much more easily.
 
-
 ## Compatibility
 
 This package is designed align and work with any officially supported Ruby and Rails versions.
@@ -56,6 +55,18 @@ This package is designed align and work with any officially supported Ruby and R
  - Latest Rails supported: 6.0.x
  - Postgres: 9.6-current(11) (probably works with most older versions to a certain point)
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_extended'
+```
+
+And then execute:
+
+    $ bundle
+
 ## Usage
 
 ### Predicate Query Methods
@@ -776,23 +787,6 @@ SELECT "people".*
   ) ) ORDER BY personal_id DESC, id DESC) people
 ```
 
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'active_record_extended'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install active_record_extended
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/active_record_extended.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "active_record_extended/version"
-require "active_record_extended/utilities"
+require "active_record_extended/utilities/support"
+require "active_record_extended/utilities/order_by"
 require "active_record_extended/active_record"
 require "active_record_extended/arel"
 

data/lib/active_record_extended/active_record.rb

@@ -21,9 +21,11 @@ require "active_record_extended/query_methods/any_of"
 require "active_record_extended/query_methods/either"
 require "active_record_extended/query_methods/inet"
 require "active_record_extended/query_methods/json"
+require "active_record_extended/query_methods/select"
 
 if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 1
   if ActiveRecord::VERSION::MINOR.zero?
+    require "active_record_extended/patch/5_0/regex_match"
     require "active_record_extended/patch/5_0/predicate_builder_decorator"
   end
   require "active_record_extended/patch/5_1/where_clause"

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -6,7 +6,7 @@ require "active_record_extended/query_methods/json"
 module ActiveRecordExtended
   module RelationPatch
     module QueryDelegation
-      delegate :with, to: :all
+      delegate :with, :foster_select, to: :all
       delegate(*::ActiveRecordExtended::QueryMethods::Unionize::UNIONIZE_METHODS, to: :all)
       delegate(*::ActiveRecordExtended::QueryMethods::Json::JSON_QUERY_METHODS, to: :all)
     end

data/lib/active_record_extended/arel.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/aggregate_function_name"
 require "active_record_extended/arel/predications"
 require "active_record_extended/arel/visitors/postgresql_decorator"

data/lib/active_record_extended/arel/aggregate_function_name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Arel
+  module Nodes
+    class AggregateFunctionName < ::Arel::Nodes::Node
+      include Arel::Predications
+      include Arel::WindowPredications
+      attr_accessor :name, :expressions, :distinct, :alias, :orderings
+
+      def initialize(name, expr, distinct = false)
+        super()
+        @name        = name.to_s.upcase
+        @expressions = expr
+        @distinct    = distinct
+      end
+
+      def order_by(expr)
+        @orderings = expr
+        self
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@name, @expressions, @distinct, @alias, @orderings].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          expressions == other.expressions &&
+          orderings == other.orderings &&
+          distinct == other.distinct
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/active_record_extended/arel/nodes.rb

@@ -1,56 +1,46 @@
 # frozen_string_literal: true
 
 require "arel/nodes/binary"
+require "arel/nodes/function"
 
 module Arel
   module Nodes
-    class Overlap < Arel::Nodes::Binary
-    end
-
-    class Contains < Arel::Nodes::Binary
-    end
-
-    class ContainsHStore < Arel::Nodes::Binary
-    end
-
-    class ContainsArray < Arel::Nodes::Binary
-    end
-
-    class ContainedInArray < Arel::Nodes::Binary
-    end
-
-    class RowToJson < Arel::Nodes::Function
-      def initialize(*args)
-        super
-        unless @expressions.is_a?(Array)
-          @expressions = Arel.sql(@expressions) unless @expressions.is_a?(Arel::Nodes::SqlLiteral)
-          @expressions = [@expressions]
+    %w[
+      Overlap
+      Contains
+      ContainsHStore
+      ContainsArray
+      ContainedInArray
+    ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+
+    %w[
+      RowToJson
+      JsonBuildObject
+      JsonbBuildObject
+      ToJson
+      ToJsonb
+      Array
+      ArrayAgg
+    ].each do |function_node_name|
+      func_klass = Class.new(::Arel::Nodes::Function) do
+        def initialize(*args)
+          super
+          return if @expressions.is_a?(::Array)
+          @expressions = @expressions.is_a?(::Arel::Node) ? [@expressions] : [::Arel.sql(@expressions)]
         end
       end
-    end
 
-    class JsonBuildObject < Arel::Nodes::Function
-      def initialize(*args)
-        super
-        @expressions = Array(@expressions)
-      end
-    end
-
-    class JsonbBuildObject < JsonBuildObject
+      const_set(function_node_name, func_klass)
     end
 
     module Inet
-      class ContainsEquals < Arel::Nodes::Binary
-      end
-
-      class ContainedWithin < Arel::Nodes::Binary
-      end
-
-      class ContainedWithinEquals < Arel::Nodes::Binary
-      end
-
-      class ContainsOrContainedWithin < Arel::Nodes::Binary
-      end
+      %w[
+        Contains
+        ContainsEquals
+        ContainedWithin
+        ContainedWithinEquals
+        ContainsOrContainedWithin
+      ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
   end
 end

data/lib/active_record_extended/arel/predications.rb

@@ -21,12 +21,15 @@ module Arel
     def contains(other)
       Nodes::Contains.new self, Nodes.build_quoted(other, self)
     end
-    alias inet_contains contains
 
     def contained_in_array(other)
       Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
     end
 
+    def inet_contains(other)
+      Nodes::Inet::Contains.new self, Nodes.build_quoted(other, self)
+    end
+
     def inet_contains_or_is_contained_within(other)
       Nodes::Inet::ContainsOrContainedWithin.new self, Nodes.build_quoted(other, self)
     end

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -23,7 +23,7 @@ module ActiveRecordExtended
         elsif left_column.try(:array)
           visit_Arel_Nodes_ContainsArray(object, collector)
         else
-          infix_value object, collector, " >> "
+          visit_Arel_Nodes_Inet_Contains(object, collector)
         end
       end
 
@@ -59,6 +59,45 @@ module ActiveRecordExtended
         aggregate "JSONB_BUILD_OBJECT", object, collector
       end
 
+      def visit_Arel_Nodes_ToJson(object, collector)
+        aggregate "TO_JSON", object, collector
+      end
+
+      def visit_Arel_Nodes_ToJsonb(object, collector)
+        aggregate "TO_JSONB", object, collector
+      end
+
+      def visit_Arel_Nodes_Array(object, collector)
+        aggregate "ARRAY", object, collector
+      end
+
+      def visit_Arel_Nodes_ArrayAgg(object, collector)
+        aggregate "ARRAY_AGG", object, collector
+      end
+
+      def visit_Arel_Nodes_AggregateFunctionName(object, collector)
+        collector << "#{object.name}("
+        collector << "DISTINCT " if object.distinct
+        collector = inject_join(object.expressions, collector, ", ")
+
+        if object.orderings
+          collector << " ORDER BY "
+          collector = inject_join(object.orderings, collector, ", ")
+        end
+        collector << ")"
+
+        if object.alias
+          collector << " AS "
+          visit object.alias, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_Inet_Contains(object, collector)
+        infix_value object, collector, " >> "
+      end
+
       def visit_Arel_Nodes_Inet_ContainedWithinEquals(object, collector)
         infix_value object, collector, " <<= "
       end

data/lib/active_record_extended/patch/5_0/predicate_builder_decorator.rb

@@ -6,20 +6,20 @@
 #
 # Without joins
 # Before:
-#   Person.where.contains(data: { nickname: "george" })
+#   User.where.contains(data: { nickname: "george" })
 #     #=> "SELECT \"people\".* FROM \"people\" WHERE (\"data\".\"nickname\" @> 'george')"
 #
 # After:
-#  Person.where.contains(data: { nickname: "george" })
+#  User.where.contains(data: { nickname: "george" })
 #   #=> "SELECT \"people\".* FROM \"people\" WHERE (\"people\".\"data\" @> '\"nickname\"=>\"george\"')"
 #
 # With Joins
 # Before:
-#   Tag.joins(:person).where.contains(people: { data: { nickname: "george" } })
+#   Tag.joins(:user).where.contains(people: { data: { nickname: "george" } })
 #   #=> NoMethodError: undefined method `type' for nil:NilClass
 #
 # After:
-#  Tag.joins(:person).where.contains(people: { data: { nickname: "george" } })
+#  Tag.joins(:user).where.contains(people: { data: { nickname: "george" } })
 #  #=> "SELECT \"tags\".* FROM \"tags\" INNER JOIN \"people\" ON \"people\".\"id\" = \"tags\".\"person_id\"
 #         WHERE (\"people\".\"data\" @> '\"nickname\"=>\"george\"')"
 #

data/lib/active_record_extended/patch/5_0/regex_match.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Regexp
+  # Stripped from ActiveSupport v5.1
+  unless //.respond_to?(:match?)
+    def match?(string, pos = 0)
+      !(!match(string, pos))
+    end
+  end
+end

data/lib/active_record_extended/query_methods/any_of.rb

@@ -28,7 +28,7 @@ module ActiveRecordExtended
       private
 
       def hash_map_queries(queries)
-        if queries.count == 1 && queries.first.is_a?(Hash)
+        if queries.size == 1 && queries.first.is_a?(Hash)
           queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
         else
           queries
@@ -38,9 +38,10 @@ module ActiveRecordExtended
       def build_query(queries)
         query_map = construct_query_mappings(queries)
         query     = yield(query_map[:arel_query], query_map[:binds])
-        query.joins(query_map[:joins].to_a)
-             .includes(query_map[:includes].to_a)
-             .references(query_map[:references].to_a)
+        query
+          .joins(query_map[:joins].to_a)
+          .includes(query_map[:includes].to_a)
+          .references(query_map[:references].to_a)
       end
 
       def construct_query_mappings(queries) # rubocop:disable Metrics/AbcSize

data/lib/active_record_extended/query_methods/inet.rb

@@ -57,7 +57,7 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >> '127.0.0.255/32'"
       #
       def inet_contains(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Contains, "inet_contains")
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::Contains, "inet_contains")
       end
 
       # This method is a combination of `inet_contains` and `inet_contained_within`

data/lib/active_record_extended/query_methods/json.rb

@@ -12,35 +12,39 @@ module ActiveRecordExtended
       ].freeze
 
       class JsonChain
-        include ::ActiveRecordExtended::Utilities
-        DEFAULT_ALIAS = '"results"'
+        include ::ActiveRecordExtended::Utilities::Support
+        include ::ActiveRecordExtended::Utilities::OrderBy
+
+        DEFAULT_ALIAS    = '"results"'
+        TO_JSONB_OPTIONS = [:array_agg, :distinct, :to_jsonb].to_set.freeze
+        ARRAY_OPTIONS    = [:array, true].freeze
 
         def initialize(scope)
           @scope = scope
         end
 
         def row_to_json!(**args, &block)
-          options = json_object_options(args).except(:values, :value)
+          options = json_object_options(args, except: [:values, :value])
           build_row_to_json(**options, &block)
         end
 
         def json_build_object!(*args)
-          options = json_object_options(args).except!(:values)
+          options = json_object_options(args, except: [:values, :cast_with, :order_by])
           build_json_object(Arel::Nodes::JsonBuildObject, **options)
         end
 
         def jsonb_build_object!(*args)
-          options = json_object_options(args).except!(:values)
+          options = json_object_options(args, except: [:values, :cast_with, :order_by])
           build_json_object(Arel::Nodes::JsonbBuildObject, **options)
         end
 
         def json_build_literal!(*args)
-          options = json_object_options(args).slice(:values, :col_alias)
+          options = json_object_options(args, only: [:values, :col_alias])
           build_json_literal(Arel::Nodes::JsonBuildObject, **options)
         end
 
         def jsonb_build_literal!(*args)
-          options = json_object_options(args).slice(:values, :col_alias)
+          options = json_object_options(args, only: [:values, :col_alias])
           build_json_literal(Arel::Nodes::JsonbBuildObject, **options)
         end
 
@@ -60,42 +64,83 @@ module ActiveRecordExtended
           col_value         = to_arel_sql(value.presence || tbl_alias)
           json_build_object = arel_klass.new(to_sql_array(col_key, col_value))
 
-          # TODO: Change this to #match?(..) when we drop Rails 5.0 or Ruby 2.4 support
-          unless col_value.index(/".+"/)
+          unless /".+"/.match?(col_value)
             warn("`#{col_value}`: the `value` argument should contain a double quoted key reference for safety")
           end
 
           @scope.select(nested_alias_escape(json_build_object, col_alias)).from(nested_alias_escape(from, tbl_alias))
         end
 
-        def build_row_to_json(from:, key: key_generator, col_alias: nil, cast_to_array: false)
-          row_to_json = Arel::Nodes::RowToJson.new(double_quote(key))
+        def build_row_to_json(from:, **options, &block)
+          key         = options[:key]
+          row_to_json = ::Arel::Nodes::RowToJson.new(double_quote(key))
+          row_to_json = ::Arel::Nodes::ToJsonb.new(row_to_json) if options.dig(:cast_with, :to_jsonb)
+
           dummy_table = from_clause_constructor(from, key).select(row_to_json)
-          dummy_table = yield dummy_table if block_given?
+          dummy_table = dummy_table.instance_eval(&block) if block_given?
+          return dummy_table if options[:col_alias].blank?
+
+          query = wrap_row_to_json(dummy_table, options)
+          @scope.select(query)
+        end
 
-          if col_alias.blank?
-            dummy_table
-          elsif cast_to_array
-            @scope.select(wrap_with_array(dummy_table, col_alias))
+        def wrap_row_to_json(dummy_table, options)
+          cast_opts = options[:cast_with]
+          col_alias = options[:col_alias]
+          order_by  = options[:order_by]
+
+          if cast_opts[:array_agg] || cast_opts[:distinct]
+            wrap_with_agg_array(dummy_table, col_alias, order_by: order_by, distinct: cast_opts[:distinct])
+          elsif cast_opts[:array]
+            wrap_with_array(dummy_table, col_alias, order_by: order_by)
           else
-            @scope.select(nested_alias_escape(dummy_table, col_alias))
+            nested_alias_escape(dummy_table, col_alias)
           end
         end
 
-        def json_object_options(*args) # rubocop:disable Metrics/AbcSize
-          flatten_safely(args).each_with_object(values: []) do |arg, options|
+        # TODO: [V2 release] Drop support for option :cast_as_array in favor of a more versatile :cast_with option
+        def json_object_options(args, except: [], only: []) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+          options   = {}
+          lean_opts = lambda do |key, &block|
+            if only.present?
+              options[key] ||= block.call if only.include?(key)
+            elsif !except.include?(key)
+              options[key] ||= block.call
+            end
+          end
+
+          flatten_safely(args) do |arg|
             next if arg.nil?
 
             if arg.is_a?(Hash)
-              options[:key]           ||= arg.delete(:key)
-              options[:value]         ||= arg.delete(:value).presence
-              options[:col_alias]     ||= arg.delete(:as)
-              options[:cast_to_array] ||= arg.delete(:cast_as_array)
-              options[:from]          ||= arg.delete(:from).tap(&method(:pipe_cte_with!))
+              lean_opts.call(:key)       { arg.delete(:key) || key_generator }
+              lean_opts.call(:value)     { arg.delete(:value).presence }
+              lean_opts.call(:col_alias) { arg.delete(:as) }
+              lean_opts.call(:order_by)  { order_by_expression(arg.delete(:order_by)) }
+              lean_opts.call(:from)      { arg.delete(:from).tap(&method(:pipe_cte_with!)) }
+              lean_opts.call(:cast_with) { casting_options(arg.delete(:cast_with) || arg.delete(:cast_as_array)) }
             end
 
-            options[:values] << (arg.respond_to?(:to_a) ? arg.to_a : arg)
-          end.compact
+            unless except.include?(:values)
+              options[:values] ||= []
+              options[:values] << (arg.respond_to?(:to_a) ? arg.to_a : arg)
+            end
+          end
+
+          options.tap(&:compact!)
+        end
+
+        def casting_options(cast_with)
+          return {} if cast_with.blank?
+
+          skip_convert = [Symbol, TrueClass, FalseClass]
+          Array(cast_with).compact.each_with_object({}) do |arg, options|
+            arg                  = arg.to_sym unless skip_convert.include?(arg.class)
+            options[:to_jsonb]  |= TO_JSONB_OPTIONS.include?(arg)
+            options[:array]     |= ARRAY_OPTIONS.include?(arg)
+            options[:array_agg] |= arg == :array_agg
+            options[:distinct]  |= arg == :distinct
+          end
         end
       end
 
@@ -111,8 +156,21 @@ module ActiveRecordExtended
       #         - This is useful if you would like to add additional mid-level clauses (see mid-level scope example)
       #
       #   - cast_as_array [boolean] (default=false): Determines if the query should be nested inside an Array() function
+      #     * Will be deprecated in V2.0 in favor of `cast_with` argument
       #
-      # Example:
+      #   - cast_with [Symbol or Array of symbols]: Actions to transform your query
+      #     * :to_jsonb
+      #     * :array
+      #     * :array_agg (including just :array with this option will favor :array_agg)
+      #     * :distinct  (auto applies :array_agg & :to_jsonb)
+      #
+      #   - order_by [Symbol or hash]: Applies an ordering operation (similar to ActiveRecord #order)
+      #     - NOTE: this option will be ignored if you need to order a DISTINCT Aggregated Array,
+      #             since postgres will thrown an error.
+      #
+      #
+      #
+      # Examples:
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
       #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
@@ -123,8 +181,74 @@ module ActiveRecordExtended
       #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
       #     scope.where(group: { name: "Nerd Core" })
       #   end
+      #    #=>  ```sql
+      #       SELECT ARRAY(
+      #             SELECT ROW_TO_JSON("group")
+      #             FROM(SELECT name, category_id FROM groups) AS group
+      #             WHERE group.name = 'Nerd Core'
+      #       )
+      #    ```
+      #
+      #
+      # - Array of JSONB objects
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_with: [:array, :to_jsonb]) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end
+      #   #=>  ```sql
+      #       SELECT ARRAY(
+      #             SELECT TO_JSONB(ROW_TO_JSON("group"))
+      #             FROM(SELECT name, category_id FROM groups) AS group
+      #             WHERE group.name = 'Nerd Core'
+      #       )
+      #   ```
+      #
+      # - Distinct Aggregated Array
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_with: [:array_agg, :distinct]) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end
+      #   #=>  ```sql
+      #      SELECT ARRAY_AGG(DISTINCT (
+      #            SELECT TO_JSONB(ROW_TO_JSON("group"))
+      #            FROM(SELECT name, category_id FROM groups) AS group
+      #            WHERE group.name = 'Nerd Core'
+      #      ))
+      #   ```
+      #
+      # - Ordering a Non-aggregated Array
+      #
+      #  subquery = Group.select(:name, :category_id)
+      #  User.select_row_to_json(subquery, key: :group, cast_with: :array, order_by: { group: { name: :desc } })
+      #  #=>  ```sql
+      #     SELECT ARRAY(
+      #           SELECT ROW_TO_JSON("group")
+      #           FROM(SELECT name, category_id FROM groups) AS group
+      #           ORDER BY group.name DESC
+      #     )
+      #  ```
+      #
+      # - Ordering an Aggregated Array
+      #
+      #  Subquery = Group.select(:name, :category_id)
+      #  User
+      #   .joins(:people_groups)
+      #  .select_row_to_json(
+      #     subquery,
+      #     key: :group,
+      #     cast_with: :array_agg,
+      #     order_by: { people_groups: :category_id }
+      #   )
+      #   #=>  ```sql
+      #     SELECT ARRAY_AGG((
+      #           SELECT ROW_TO_JSON("group")
+      #           FROM(SELECT name, category_id FROM groups) AS group
+      #           ORDER BY group.name DESC
+      #     ) ORDER BY people_groups.category_id ASC)
+      #   ```
       #
-
       def select_row_to_json(from = nil, **options, &block)
         from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
         options.compact!
@@ -163,21 +287,6 @@ module ActiveRecordExtended
       #        .take
       #        .results["gang_members"] #=> "BANG!"
       #
-      #
-      # - Adding mid-level scopes
-      #
-      #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
-      #     scope.where(group: { name: "Nerd Core" })
-      #   end  #=>  ```sql
-      #       SELECT ARRAY(
-      #             SELECT ROW_TO_JSON("group")
-      #             FROM(SELECT name, category_id FROM groups) AS group
-      #             WHERE group.name = 'Nerd Core'
-      #       )
-      #     ```
-      #
-
       def json_build_object(key, from, **options)
         options[:key]  = key
         options[:from] = from