active_record_extended 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29516f7d7b4854e6a04653d6e146e5945efa9ade39ad99d171e17bd2f11e1fe3
-  data.tar.gz: f898fa543fe7d79f9fa98e015e86044cccf7ae4c940abe13c912fbb9d435a010
+  metadata.gz: 9934d5a90324b46dc3faa7b496724ac219a2582d264db89e64e2b9be574adab6
+  data.tar.gz: c1359988f9a6b83148f36548e842a25cab68a191e7a839caef7e783b1415b346
 SHA512:
-  metadata.gz: b10866d1c5e95ddb6e37df09085b1e86183bfa9b4b217b71f5f3ce8973926fc6f83591c352515098d5800276afaf1ff538ac50bea8cd5f355da7d67768570970
-  data.tar.gz: 654a00730852609edf1ef1e47893896647d06548bc563aa4546713b7398981fbe050d7951dee47eb2b97c673e370ff40b0949aa763c6665662deb3c08625bc53
+  metadata.gz: e7385b414ef4c8d8b0c5b29eaeb70e77ba79f07828255deef5db79e99cf33f18de7bab696501711dee1f8e056ca3bdf628cdd498b341a91b5ad5cd2c766bd61c
+  data.tar.gz: 10e8d4f65c570dba757b2cf47aaaff7f8a5538974e9c8aadb3c267e3e3fccb9508b05a8722eb5d6680937cb15827f6fa4f88d6dd219d8240c58323385fe44eb2

data/README.md

@@ -52,11 +52,12 @@ Active Record Extended is essentially providing users with the other half of Pos
 ## Compatibility
 
 This package is designed align and work with any officially supported Ruby and Rails versions.
- - Minimum Ruby Version: 2.3.x **(EOL warning!)**
- - Minimum Rails Version: 5.0.x **(EOL warning!)**
- - Latest Ruby supported: 2.6.x
- - Latest Rails supported: 6.0.x
- - Postgres: 9.6-current(11) (probably works with most older versions to a certain point)
+ - Minimum Ruby Version: 2.4.x **(EOL warning!)**
+ - Minimum Rails Version: 5.1.x **(EOL warning!)**
+ - Minimum Postgres Version: 9.6.x **(EOL warning!)**
+ - Latest Ruby supported: 2.7.x
+ - Latest Rails supported: 6.1.x
+ - Postgres: 9.6-current(13) (probably works with most older versions to a certain point)
 
 ## Installation
 
@@ -430,7 +431,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
     product_query  = 
     Product.select(:id)
             .joins(:items)
-            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_as_array: true) do |item_scope|
+            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_with: :array) do |item_scope|
               item_scope.where("outer_items.product_id = products.id")
                 # Results to: 
                 #  SELECT ..., ARRAY(SELECT ROW_TO_JSON("outer_items")   
@@ -440,7 +441,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
             end
                    
     # Not defining a key will automatically generate a random key between a-z 
-    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_as_array: true)
+    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_with: :array)
     Category.json_build_object(:physical_category, category_query.where(id: physical_cat.id)).results
     #=> {
     #        "physical_category" => {

data/lib/active_record_extended/active_record.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-# TODO: Remove this when ruby 2.3 support is dropped
-unless Hash.instance_methods(false).include?(:compact!)
-  require "active_support/all"
-end
-
 require "active_record"
 require "active_record/relation"
 require "active_record/relation/merger"
@@ -23,11 +18,7 @@ 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
+if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 1
   require "active_record_extended/patch/5_1/where_clause"
 elsif ActiveRecord::VERSION::MAJOR >= 5
   require "active_record_extended/patch/5_2/where_clause"

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -14,7 +14,22 @@ module ActiveRecordExtended
 
     module Merger
       def normal_values
-        super + [:with, :union, :define_window]
+        super + [:union, :define_window]
+      end
+
+      def merge
+        merge_ctes!
+        super
+      end
+
+      def merge_ctes!
+        return unless other.with_values?
+
+        if other.recursive_value? && !relation.recursive_value?
+          relation.with!(:chain).recursive(other.cte)
+        else
+          relation.with!(other.cte)
+        end
       end
     end
 

data/lib/active_record_extended/arel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/sql_literal"
 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/nodes.rb

@@ -5,28 +5,29 @@ require "arel/nodes/function"
 
 module Arel
   module Nodes
-    %w[
-      Overlap
-      Contains
-      ContainsHStore
-      ContainsArray
-      ContainedInArray
+    [
+      "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
+    [
+      "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)]
+
+          @expressions = @expressions.is_a?(::Arel::Nodes::Node) ? [@expressions] : [::Arel.sql(@expressions)]
         end
       end
 
@@ -34,12 +35,12 @@ module Arel
     end
 
     module Inet
-      %w[
-        Contains
-        ContainsEquals
-        ContainedWithin
-        ContainedWithinEquals
-        ContainsOrContainedWithin
+      [
+        "Contains",
+        "ContainsEquals",
+        "ContainedWithin",
+        "ContainedWithinEquals",
+        "ContainsOrContainedWithin"
       ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
   end

data/lib/active_record_extended/arel/sql_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "arel/nodes/sql_literal"
+
+# CTE alias fix for Rails 6.1
+module Arel
+  module Nodes
+    module SqlLiteralDecorator
+      def name
+        self
+      end
+    end
+  end
+end
+
+Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralDecorator)

data/lib/active_record_extended/query_methods/any_of.rb

@@ -61,13 +61,14 @@ module ActiveRecordExtended
       # In Rails 5.2 the arel table maintains attribute binds
       def bind_attributes(query)
         return [] unless query.respond_to?(:bound_attributes)
+
         query.bound_attributes.map(&:value)
       end
 
       # Rails 5.1 fix
       def unprepared_query(query)
-        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d+)/) do |match|
-          Regexp.last_match(2)&.gsub(/\=\ \$\d+/, "= ?") || match
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/=\ \$\d+/, "= ?") || match
         end
       end
 
@@ -78,9 +79,9 @@ module ActiveRecordExtended
       def generate_where_clause(query)
         case query
         when String, Hash
-          @scope.where(query)
+          @scope.unscoped.where(query)
         when Array
-          @scope.where(*query)
+          @scope.unscoped.where(*query)
         else
           query
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -30,7 +30,7 @@ module ActiveRecordExtended
       end
 
       def sort_order_sql(dir)
-        %w[asc desc].include?(dir.to_s) ? dir.to_s : "asc"
+        ["asc", "desc"].include?(dir.to_s) ? dir.to_s : "asc"
       end
 
       def xor_field_options(options)

data/lib/active_record_extended/query_methods/inet.rb

@@ -74,8 +74,12 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.0.255/32'"
       #
       def inet_contains_or_is_contained_within(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsOrContainedWithin,
-                               "inet_contains_or_is_contained_within")
+        substitute_comparisons(
+          opts,
+          rest,
+          Arel::Nodes::Inet::ContainsOrContainedWithin,
+          "inet_contains_or_is_contained_within"
+        )
       end
     end
   end

data/lib/active_record_extended/query_methods/json.rb

@@ -8,7 +8,7 @@ module ActiveRecordExtended
         :json_build_object,
         :jsonb_build_object,
         :json_build_literal,
-        :jsonb_build_literal,
+        :jsonb_build_literal
       ].freeze
 
       class JsonChain
@@ -77,7 +77,7 @@ module ActiveRecordExtended
           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 = dummy_table.instance_eval(&block) if block_given?
+          dummy_table = dummy_table.instance_eval(&block) if block
           return dummy_table if options[:col_alias].blank?
 
           query = wrap_row_to_json(dummy_table, options)
@@ -98,7 +98,6 @@ module ActiveRecordExtended
           end
         end
 
-        # 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|
@@ -113,12 +112,12 @@ module ActiveRecordExtended
             next if arg.nil?
 
             if arg.is_a?(Hash)
-              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 { |from_clause| pipe_cte_with!(from_clause) } }
-              lean_opts.call(:cast_with) { casting_options(arg.delete(:cast_with) || arg.delete(:cast_as_array)) }
+              lean_opts.call(:key)       { arg.fetch(:key, key_generator) }
+              lean_opts.call(:value)     { arg[:value].presence }
+              lean_opts.call(:col_alias) { arg[:as] }
+              lean_opts.call(:order_by)  { order_by_expression(arg[:order_by]) }
+              lean_opts.call(:from)      { arg[:from].tap { |from_clause| pipe_cte_with!(from_clause) } }
+              lean_opts.call(:cast_with) { casting_options(arg[:cast_with]) }
             end
 
             unless except.include?(:values)
@@ -155,9 +154,6 @@ module ActiveRecordExtended
       #   - key: [Symbol or String] (default=[random letter]) What the row clause will be set as.
       #         - 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
-      #
       #   - cast_with [Symbol or Array of symbols]: Actions to transform your query
       #     * :to_jsonb
       #     * :array
@@ -172,13 +168,13 @@ module ActiveRecordExtended
       #
       # 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.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Adding mid-level scopes:
       #
       #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #   User.select_row_to_json(subquery, key: :group, cast_with: :array) do |scope|
       #     scope.where(group: { name: "Nerd Core" })
       #   end
       #    #=>  ```sql
@@ -252,7 +248,8 @@ module ActiveRecordExtended
       def select_row_to_json(from = nil, **options, &block)
         from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
         options.compact!
-        raise ArgumentError, "Required to provide a non-nilled from clause" unless options.key?(:from)
+        raise ArgumentError.new("Required to provide a non-nilled from clause") unless options.key?(:from)
+
         JsonChain.new(spawn).row_to_json!(**options, &block)
       end
 
@@ -273,7 +270,7 @@ module ActiveRecordExtended
       #   - Generic example:
       #
       #   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.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Setting a custom value:

data/lib/active_record_extended/query_methods/select.rb

@@ -52,12 +52,12 @@ module ActiveRecordExtended
         #  #=> SELECT (ARRAY_AGG(DISTINCT members.price)) AS past_purchases, ...
         def process_hash!(hash_of_options, alias_name)
           enforced_options = {
-            cast_with: hash_of_options.delete(:cast_with),
-            order_by:  hash_of_options.delete(:order_by),
-            distinct:  !(!hash_of_options.delete(:distinct)),
+            cast_with: hash_of_options[:cast_with],
+            order_by:  hash_of_options[:order_by],
+            distinct:  !(!hash_of_options[:distinct])
           }
-          query_statement = hash_to_dot_notation(hash_of_options.delete(:__select_statement) || hash_of_options.first)
-          select!(query_statement, alias_name, enforced_options)
+          query_statement = hash_to_dot_notation(hash_of_options[:__select_statement] || hash_of_options.first)
+          select!(query_statement, alias_name, **enforced_options)
         end
 
         # Turn a hash chain into a query statement:
@@ -76,7 +76,7 @@ module ActiveRecordExtended
         # Add's select statement values to the current relation, select statement lists
         def select!(query, alias_name = nil, **options)
           pipe_cte_with!(query)
-          @scope._select!(to_casted_query(query, alias_name, options))
+          @scope._select!(to_casted_query(query, alias_name, **options))
         end
 
         # Wraps the query with the requested query method
@@ -84,9 +84,9 @@ module ActiveRecordExtended
         #   to_casted_query("memberships.cost", :total_revenue, :sum)
         #    #=> SELECT (SUM(memberships.cost)) AS total_revenue
         def to_casted_query(query, alias_name, **options)
-          cast_with  = options.delete(:cast_with).to_s.downcase
-          order_expr = order_by_expression(options.delete(:order_by))
-          distinct   = cast_with.chomp!("_distinct") || options.delete(:distinct) # account for [:agg_name:]_distinct
+          cast_with  = options[:cast_with].to_s.downcase
+          order_expr = order_by_expression(options[:order_by])
+          distinct   = cast_with.chomp!("_distinct") || options[:distinct] # account for [:agg_name:]_distinct
 
           case cast_with
           when "array", "true"
@@ -102,7 +102,8 @@ module ActiveRecordExtended
       end
 
       def foster_select(*args)
-        raise ArgumentError, "Call `.forster_select' with at least one field" if args.empty?
+        raise ArgumentError.new("Call `.forster_select' with at least one field") if args.empty?
+
         spawn._foster_select!(*args)
       end
 

data/lib/active_record_extended/query_methods/unionize.rb

@@ -81,7 +81,7 @@ module ActiveRecordExtended
           union_values:          [],
           union_operations:      [],
           union_ordering_values: [],
-          unionized_name:        nil,
+          unionized_name:        nil
         }
       end
 
@@ -89,10 +89,11 @@ module ActiveRecordExtended
         union_values:          Array,
         union_operations:      Array,
         union_ordering_values: Array,
-        unionized_name:        lambda { |klass| klass.arel_table.name },
+        unionized_name:        lambda { |klass| klass.arel_table.name }
       }.each_pair do |method_name, default|
         define_method(method_name) do
           return unionize_storage[method_name] if send("#{method_name}?")
+
           (default.is_a?(Proc) ? default.call(@klass) : default.new)
         end
 
@@ -107,11 +108,13 @@ module ActiveRecordExtended
 
       def union(opts = :chain, *args)
         return UnionChain.new(spawn) if opts == :chain
+
         opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
       end
 
       (UNIONIZE_METHODS + UNION_RELATION_METHODS).each do |union_method|
         next if union_method == :union
+
         alias_method union_method, :union
       end
 
@@ -126,11 +129,13 @@ module ActiveRecordExtended
       # Will construct *Just* the union SQL statement that was been built thus far
       def to_union_sql
         return unless union_values?
+
         apply_union_ordering(build_union_nodes!(false)).to_sql
       end
 
       def to_nice_union_sql(color = true)
         return to_union_sql unless defined?(::Niceql)
+
         ::Niceql::Prettifier.prettify_sql(to_union_sql, color)
       end
 
@@ -172,7 +177,7 @@ module ActiveRecordExtended
 
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
-        union_values.each_with_index.inject(nil) do |union_node, (relation_node, index)|
+        union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
           next resolve_relation_node(relation_node) if union_node.nil?
 
           operation = union_operations.fetch(index - 1, :union)
@@ -215,6 +220,7 @@ module ActiveRecordExtended
       #
       def apply_union_ordering(union_nodes)
         return union_nodes unless union_ordering_values?
+
         UnionChain.new(self).inline_order_by(union_nodes, union_ordering_values)
       end
 
@@ -222,7 +228,7 @@ module ActiveRecordExtended
 
       def unionize_error_or_warn!(raise_error = true)
         if raise_error && union_values.size <= 1
-          raise ArgumentError, "You are required to provide 2 or more unions to join!"
+          raise ArgumentError.new("You are required to provide 2 or more unions to join!")
         elsif !raise_error && union_values.size <= 1
           warn("Warning: You are required to provide 2 or more unions to join.")
         end