active_record_extended 1.4.0 → 2.0.0

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -54,10 +54,10 @@ module ActiveRecordExtended
           elsif column.try(:array)
             Arel::Nodes::ContainsArray.new(arel.left, arel.right)
           else
-            raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+            raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
           end
         else
-          raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
         end
       end
     end
@@ -88,7 +88,7 @@ module ActiveRecordExtended
         when Arel::Nodes::Equality
           Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
         else
-          raise ArgumentError, "Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
         end
       end
     end
@@ -99,10 +99,18 @@ module ActiveRecordExtended
         when Arel::Nodes::In, Arel::Nodes::Equality
           arel_node_class.new(arel.left, arel.right)
         else
-          raise ArgumentError, "Invalid argument for .where.#{method}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
         end
       end
     end
+
+    def build_where_clause_for(scope, opts, rest)
+      if ActiveRecord::VERSION::MAJOR == 6 && ActiveRecord::VERSION::MINOR == 1
+        scope.send(:build_where_clause, opts, rest)
+      else
+        scope.send(:where_clause_factory).build(opts, rest)
+      end
+    end
   end
 end
 
@@ -112,9 +120,9 @@ module ActiveRecord
       prepend ActiveRecordExtended::WhereChain
 
       def build_where_chain(opts, rest, &block)
-        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+        where_clause = build_where_clause_for(@scope, opts, rest)
         @scope.tap do |scope|
-          scope.references!(PredicateBuilder.references(opts)) if opts.is_a?(Hash)
+          scope.references!(PredicateBuilder.references(opts.stringify_keys)) if opts.is_a?(Hash)
           scope.where_clause += where_clause.modified_predicates(&block)
         end
       end

data/lib/active_record_extended/query_methods/window.rb

@@ -16,7 +16,7 @@ module ActiveRecordExtended
           @scope.window_values! << {
             window_name:  to_arel_sql(@window_name),
             partition_by: flatten_to_sql(partitions),
-            order_by:     order_by_expression(order_by),
+            order_by:     order_by_expression(order_by)
           }
 
           @scope
@@ -81,8 +81,9 @@ module ActiveRecordExtended
 
       def build_windows(arel)
         window_values.each do |window_value|
-          window = arel.window(window_value[:window_name]).partition(window_value[:partition_by])
-          window.order(window_value[:order_by]) if window_value[:order_by]
+          window = arel.window(window_value[:window_name])
+          window = window.partition(window_value[:partition_by]) if window_value[:partition_by].present?
+          window.order(window_value[:order_by])                  if window_value[:order_by]
         end
       end
     end

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -3,78 +3,145 @@
 module ActiveRecordExtended
   module QueryMethods
     module WithCTE
-      class WithChain
+      class WithCTE
+        include ::ActiveRecordExtended::Utilities::Support
+        include Enumerable
+        extend  Forwardable
+
+        def_delegators :@with_values, :empty?, :blank?, :present?
+        attr_reader :with_values, :with_keys
+
+        # @param [ActiveRecord::Relation] scope
         def initialize(scope)
           @scope = scope
+          reset!
+        end
+
+        # @return [Enumerable] Returns the order for which CTE's were imported as.
+        def each
+          return to_enum(:each) unless block_given?
+
+          with_keys.each do |key|
+            yield(key, with_values[key])
+          end
+        end
+        alias each_pair each
+
+        # @param [Hash, WithCTE] value
+        def with_values=(value)
+          reset!
+          pipe_cte_with!(value)
         end
 
-        def recursive(*args)
+        # @param [Hash, WithCTE] value
+        def pipe_cte_with!(value)
+          return if value.nil? || value.empty?
+
+          value.each_pair do |name, expression|
+            sym_name = name.to_sym
+            next if with_values.key?(sym_name)
+
+            # Ensure we follow FIFO pattern.
+            # If the parent has similar CTE alias keys, we want to favor the parent's expressions over its children's.
+            if expression.is_a?(ActiveRecord::Relation) && expression.with_values?
+              pipe_cte_with!(expression.cte)
+              expression.cte.reset!
+            end
+
+            @with_keys            |= [sym_name]
+            @with_values[sym_name] = expression
+          end
+
+          value.reset! if value.is_a?(WithCTE)
+        end
+
+        def reset!
+          @with_keys   = []
+          @with_values = {}
+        end
+      end
+
+      class WithChain
+        # @param [ActiveRecord::Relation] scope
+        def initialize(scope)
+          @scope       = scope
+          @scope.cte ||= WithCTE.new(scope)
+        end
+
+        # @param [Hash, WithCTE] args
+        def recursive(args)
           @scope.tap do |scope|
-            scope.with_values    += args
             scope.recursive_value = true
+            scope.cte.pipe_cte_with!(args)
           end
         end
       end
 
-      def with_values
-        @values[:with] || []
+      # @return [WithCTE]
+      def cte
+        @values[:cte]
+      end
+
+      # @param [WithCTE] cte
+      def cte=(cte)
+        raise TypeError.new("Must be a WithCTE class type") unless cte.is_a?(WithCTE)
+
+        @values[:cte] = cte
       end
 
+      # @return [Boolean]
       def with_values?
-        !(@values[:with].nil? || @values[:with].empty?)
+        !(cte.nil? || cte.empty?)
       end
 
+      # @param [Hash, WithCTE] values
       def with_values=(values)
-        @values[:with] = values
+        cte.with_values = values
       end
 
+      # @param [Boolean] value
       def recursive_value=(value)
         raise ImmutableRelation if @loaded
+
         @values[:recursive] = value
       end
 
-      def recursive_value
-        @values[:recursive]
+      # @return [Boolean]
+      def recursive_value?
+        !(!@values[:recursive])
       end
-      alias recursive_value? recursive_value
 
+      # @param [Hash, WithCTE] opts
       def with(opts = :chain, *rest)
         return WithChain.new(spawn) if opts == :chain
+
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
-      def with!(opts = :chain, *rest)
+      # @param [Hash, WithCTE] opts
+      def with!(opts = :chain, *_rest)
         return WithChain.new(self) if opts == :chain
-        self.with_values += [opts] + rest
-        self
-      end
 
-      def build_with_hashed_value(with_value)
-        with_value.map do |name, expression|
-          select =
-            case expression
-            when String
-              Arel.sql("(#{expression})")
-            when ActiveRecord::Relation, Arel::SelectManager
-              Arel.sql("(#{expression.to_sql})")
-            end
-          next if select.nil?
-          Arel::Nodes::As.new(Arel.sql(PG::Connection.quote_ident(name.to_s)), select)
+        tap do |scope|
+          scope.cte ||= WithCTE.new(self)
+          scope.cte.pipe_cte_with!(opts)
         end
       end
 
       def build_with(arel)
-        with_statements = with_values.flat_map do |with_value|
-          case with_value
-          when String, Arel::Nodes::As
-            with_value
-          when Hash
-            build_with_hashed_value(with_value)
-          end
-        end.compact
+        return unless with_values?
+
+        cte_statements = cte.map do |name, expression|
+          grouped_expression = cte.generate_grouping(expression)
+          cte_name           = cte.to_arel_sql(cte.double_quote(name.to_s))
+          Arel::Nodes::As.new(cte_name, grouped_expression)
+        end
 
-        return if with_statements.empty?
-        recursive_value? ? arel.with(:recursive, with_statements) : arel.with(with_statements)
+        if recursive_value?
+          arel.with(:recursive, cte_statements)
+        else
+          arel.with(cte_statements)
+        end
       end
     end
   end

data/lib/active_record_extended/utilities/order_by.rb

@@ -60,34 +60,15 @@ module ActiveRecordExtended
         end
       end
 
-      # We'll need to preprocess these arguments for allowing `ActiveRecord::Relation#preprocess_order_args`,
-      # to check for sanitization issues and convert over to `Arel::Nodes::[Ascending/Descending]`.
-      # Without reflecting / prepending the parent's table name.
-      #
-      if ActiveRecord.gem_version < Gem::Version.new("5.1")
-        # TODO: Rails 5.0.x order logic will *always* append the parents name to the column when its an HASH obj
-        #       We should really do this stuff better. Maybe even just ignore `preprocess_order_args` altogether?
-        #       Maybe I'm just stupidly over paranoid on just the 'ORDER BY' for some odd reason.
-        def process_ordering_arguments!(ordering_args)
-          ordering_args.flatten!
-          ordering_args.compact!
-          ordering_args.map! do |arg|
-            next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-            arg.each_with_object([]) do |(field, dir), ordering_object|
-              ordering_object << to_arel_sql(field).send(dir.to_s.downcase)
-            end
-          end.flatten!
-        end
-      else
-        def process_ordering_arguments!(ordering_args)
-          ordering_args.flatten!
-          ordering_args.compact!
-          ordering_args.map! do |arg|
-            next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-            arg.each_with_object({}) do |(field, dir), ordering_obj|
-              # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
-              ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
-            end
+      def process_ordering_arguments!(ordering_args)
+        ordering_args.flatten!
+        ordering_args.compact!
+        ordering_args.map! do |arg|
+          next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
+
+          arg.each_with_object({}) do |(field, dir), ordering_obj|
+            # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
+            ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
           end
         end
       end

data/lib/active_record_extended/utilities/support.rb

@@ -20,7 +20,7 @@ module ActiveRecordExtended
 
       def flatten_safely(values, &block)
         unless values.is_a?(Array)
-          values = yield values if block_given?
+          values = yield values if block
           return [values]
         end
 
@@ -91,20 +91,12 @@ module ActiveRecordExtended
       def pipe_cte_with!(subquery)
         return self unless subquery.try(:with_values?)
 
-        cte_ary              = flatten_safely(subquery.with_values)
-        subquery.with_values = nil # Remove nested queries with values
-
-        # Add subquery's CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+        # Add subquery CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
         if @scope.with_values?
-          # combine top-level and lower level queries `.with` values into 1 structure
-          with_hash = cte_ary.each_with_object(@scope.with_values.first) do |from_cte, hash|
-            hash.reverse_merge!(from_cte)
-          end
-
-          @scope.with_values = [with_hash]
+          @scope.cte.pipe_cte_with!(subquery.cte)
         else
           # Top level has no with values
-          @scope.with!(*cte_ary)
+          @scope.with!(subquery.cte)
         end
 
         self
@@ -143,13 +135,13 @@ module ActiveRecordExtended
       # Converts a potential subquery into a compatible Arel SQL node.
       #
       # Note:
-      # We convert relations to SQL to maintain compatibility with Rails 5.[0/1].
+      # We convert relations to SQL to maintain compatibility with Rails 5.1.
       # Only Rails 5.2+ maintains bound attributes in Arel, so its better to be safe then sorry.
-      # When we drop support for Rails 5.[0/1], we then can then drop the '.to_sql' conversation
+      # When we drop support for Rails 5.1, we then can then drop the '.to_sql' conversation
 
       def to_arel_sql(value)
         case value
-        when Arel::Node, Arel::Nodes::SqlLiteral, nil
+        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, nil
           value
         when ActiveRecord::Relation
           Arel.sql(value.spawn.to_sql)
@@ -160,6 +152,7 @@ module ActiveRecordExtended
 
       def group_when_needed(arel_or_rel_query)
         return arel_or_rel_query unless needs_to_be_grouped?(arel_or_rel_query)
+
         generate_grouping(arel_or_rel_query)
       end
 

data/lib/active_record_extended/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

data/spec/query_methods/any_of_spec.rb

@@ -61,7 +61,7 @@ RSpec.describe "Active Record Any / None of Methods" do
       it "Return matched records of a joined table on the parent level" do
         query = Tag.joins(:user).where.any_of(
           { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_one, tag_three)
@@ -120,7 +120,7 @@ RSpec.describe "Active Record Any / None of Methods" do
       it "Return matched records of a joined table on the parent level" do
         query = Tag.joins(:user).where.none_of(
           { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_two)

data/spec/query_methods/json_spec.rb

@@ -47,7 +47,7 @@ RSpec.describe "Active Record JSON methods" do
     end
 
     it "allows for casting results in an aggregate-able Array function" do
-      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_as_array: true)
+      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_with: :array)
       expect(query.take.results).to be_a(Array).and(be_present)
       expect(query.take.results.first).to be_a(Hash)
     end
@@ -61,14 +61,14 @@ RSpec.describe "Active Record JSON methods" do
 
   describe ".json_build_object" do
     let(:sub_query) do
-      User.select_row_to_json(from: User.select(:id), cast_as_array: true, as: :ids).where(id: user_one.id)
+      User.select_row_to_json(from: User.select(:id), cast_with: :array, as: :ids).where(id: user_one.id)
     end
 
     it "defaults the column alias if one is not provided" do
       query = User.json_build_object(:personal, sub_query)
       expect(query.size).to eq(1)
       expect(query.take.results).to match(
-        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }])),
+        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }]))
       )
     end
 
@@ -98,7 +98,7 @@ RSpec.describe "Active Record JSON methods" do
         :personal,
         sub_query.where.not(id: user_one),
         value: "COALESCE(array_agg(\"personal\"), '{}')",
-        as:    :cool_dudes,
+        as:    :cool_dudes
       )
 
       expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
@@ -110,7 +110,7 @@ RSpec.describe "Active Record JSON methods" do
           :personal,
           sub_query.where.not(id: user_one),
           value: "COALESCE(array_agg(personal), '{}')",
-          as:    :cool_dudes,
+          as:    :cool_dudes
         )
       end.to output.to_stderr
     end

data/spec/query_methods/select_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe "Active Record Select Methods" do
         it "can accept a subquery" do
           subquery = Tag.select("count(*)").joins("JOIN users u ON tags.user_id = u.id").where("u.ip = users.ip")
           query    =
-            User.foster_select(tag_count: [subquery, cast_with: :array_agg, distinct: true])
+            User.foster_select(tag_count: [subquery, { cast_with: :array_agg, distinct: true }])
                 .joins(:hm_tags)
                 .group(:ip)
                 .take
@@ -25,8 +25,8 @@ RSpec.describe "Active Record Select Methods" do
 
         it "can be ordered" do
           query = User.foster_select(
-            asc_ordered_numbers:  [:number, cast_with: :array_agg, order_by: { number: :asc }],
-            desc_ordered_numbers: [:number, cast_with: :array_agg, order_by: { number: :desc }],
+            asc_ordered_numbers:  [:number, { cast_with: :array_agg, order_by: { number: :asc } }],
+            desc_ordered_numbers: [:number, { cast_with: :array_agg, order_by: { number: :desc } }]
           ).take
 
           expect(query.asc_ordered_numbers).to eq(number_set.to_a.sort)
@@ -50,10 +50,10 @@ RSpec.describe "Active Record Select Methods" do
 
         it "will return a boolean expression" do
           query = User.foster_select(
-            truthly_expr:     ["users.number > 0",   cast_with: :bool_and],
-            falsey_expr:      ["users.number > 200", cast_with: :bool_and],
-            other_true_expr:  ["users.number > 4",   cast_with: :bool_or],
-            other_false_expr: ["users.number > 6",   cast_with: :bool_or],
+            truthly_expr:     ["users.number > 0",   { cast_with: :bool_and }],
+            falsey_expr:      ["users.number > 200", { cast_with: :bool_and }],
+            other_true_expr:  ["users.number > 4",   { cast_with: :bool_or }],
+            other_false_expr: ["users.number > 6",   { cast_with: :bool_or }]
           ).take
 
           expect(query.truthly_expr).to be_truthy
@@ -67,19 +67,19 @@ RSpec.describe "Active Record Select Methods" do
         before { 2.times.flat_map { |i| Array.new(2) { |j| User.create!(number: (i + 1) * j + 3) } } }
 
         it "max" do
-          query = User.foster_select(max_num: [:number, cast_with: :max]).take
+          query = User.foster_select(max_num: [:number, { cast_with: :max }]).take
           expect(query.max_num).to eq(5)
         end
 
         it "min" do
-          query = User.foster_select(max_num: [:number, cast_with: :min]).take
+          query = User.foster_select(max_num: [:number, { cast_with: :min }]).take
           expect(query.max_num).to eq(3)
         end
 
         it "sum" do
           query = User.foster_select(
-            num_sum:      [:number, cast_with: :sum],
-            distinct_sum: [:number, cast_with: :sum, distinct: true],
+            num_sum:      [:number, { cast_with: :sum }],
+            distinct_sum: [:number, { cast_with: :sum, distinct: true }]
           ).take
 
           expect(query.num_sum).to eq(15)
@@ -88,8 +88,8 @@ RSpec.describe "Active Record Select Methods" do
 
         it "avg" do
           query = User.foster_select(
-            num_avg:      [:number, cast_with: :avg],
-            distinct_avg: [:number, cast_with: :avg, distinct: true],
+            num_avg:      [:number, { cast_with: :avg }],
+            distinct_avg: [:number, { cast_with: :avg, distinct: true }]
           ).take
 
           expect(query.num_avg).to eq(3.75)