active_record_relation_in 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ce1d6dc9172035c97ed5360be175b27798667d8aaca6a88d3dc6077fb3d1f84
+  data.tar.gz: a68c0e828707ee8010ebf1a4371523948baf3a24beb991dca01e47e00fa1a3b8
+SHA512:
+  metadata.gz: 84a88ba27d53ee59bb12aa6a753ef1c3d017a00b8ee6dec66d1a3baaab859877e438f685e1aa37da4151d72b5e76482767b0ab710405db21845d648818501ec9
+  data.tar.gz: 1fd5a4e73d28459c59c7e97cb4e08459c1f94acd4d775724842fdcc7f5acd69f5eb8969b140eb6dfbbb11c5dc1a9458bb65f2ad053603884c1df7e8b05ff7fb4

data/README.md

@@ -0,0 +1,75 @@
+## Index
+- [Description and history](#description-and-history)
+- [Compatibility](#compatibility)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Scope Modifiers](#scope-modifiers)
+    - [Combine With IN](#combine-with-in)
+
+## Description and History
+
+Active Record Relation In grew out of the frustration that certain combining of scopes would make them not function.
+
+By default ActiveRecord combines different where statements with an AND statement. This makes it hard to write scopes that can be combined without doing a lot of trickery.
+
+Active Record Relation In is the continuation of maintaining and improving the work done by **George Protacio-Karaszi**, the original author of [active_record_extended](https://github.com/GeorgeKaraszi/ActiveRecordExtended).
+
+Since it's a great start of how to make sure combines correctly with Active Record and this feature was a bit to specific for them to want in their gem.
+
+## Compatibility
+
+This package is designed align and work with any officially supported Ruby and Rails versions.
+ - Minimum Ruby Version: 3.1.x **(EOL warning!)**
+ - Minimum Rails Version: 6.1.x **(EOL warning!)**
+ - Minimum Postgres Version: 12.x **(EOL warning!)**
+ - Latest Ruby supported: 3.3.x
+ - Latest Rails supported: 7.1.x
+ - Postgres: 11-current(16) (probably works with most older versions to a certain point)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_relation_in'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+#### Scope Modifiers
+
+#### Combine With IN
+
+When you want to combine with statement with an IN statement instead of the usual AND statement
+
+`.combine_with_in/0`
+
+```ruby
+class User < ApplicationRecord
+end
+
+
+class Tag < ApplicationRecord
+  belongs_to :user
+  scope :for_users, ->(user_ids) { where(user_id: user_ids).combine_with_in }
+end
+
+Tag.where(id: 1).for_users([1, 2]).for_users(3)
+```
+
+Query Output
+```sql
+SELECT "tags".*
+FROM "tags"
+WHERE
+"tags"."id" = 1 AND
+"tags"."user_id" IN (1, 2, 3)
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/active_record_relation_in/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationIn
+  VERSION = "0.1.0"
+end

data/lib/active_record_relation_in/where_clause/combine_with_in_relation.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationIn
+  module WhereClause
+    class CombineWithInRelation < ActiveRecord::Relation::WhereClause
+      def ast
+        predicates = predicates_with_wrapped_sql_literals
+        return predicates.first if predicates.one?
+
+        equality_predicats, other_predicats = split_predicates(predicates)
+
+        return Arel::Nodes::And.new(predicates) if equality_predicats.empty?
+
+        ast_for_equality_predicates(equality_predicats, other_predicats)
+      end
+
+      private
+
+      def ast_for_equality_predicates(equality_predicats, other_predicats)
+        grouped_equality_predicates = equality_predicats.group_by { |equality_predicat| equality_predicat.right.name }
+        if grouped_equality_predicates.one? && other_predicats.empty?
+          values = predicate_values(predicates)
+          attribute = predicates.first.left
+          Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
+        else
+          combined_predicates = other_predicats + equality_predicates(grouped_equality_predicates)
+          Arel::Nodes::And.new(combined_predicates)
+        end
+      end
+
+      def predicate_values(predicates)
+        predicates.map do |predicate|
+          value = predicate.right.value
+          if value.instance_of?(Hash)
+            value.map { |key, hash_values| hash_values.map { |hash_value| hash_value[key] } }
+          else
+            value
+          end
+        end.flatten
+      end
+
+      def split_predicates(predicates)
+        predicates.each_with_object([[], []]) do |predicate, acc|
+          if predicate.instance_of?(Arel::Nodes::Equality)
+            [acc.first.push(predicate), acc.last]
+          else
+            [acc.first, acc.last.push(predicate)]
+          end
+        end
+      end
+
+      def equality_predicates(grouped_equality_predicates)
+        grouped_equality_predicates.values.map do |predicates_by_name|
+          if predicates_by_name.one?
+            predicates_by_name.first
+          else
+            values = predicate_values(predicates_by_name)
+            attribute = predicates_by_name.first.left
+            Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_relation_in/where_clause/relation_patch.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationIn
+  module WhereClause
+    module RelationPatch
+      module RelationCombineInPatch
+        def combine_with_in
+          self.where_clause = where_clause.combine_with_in
+
+          self
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordRelationIn::WhereClause::RelationPatch::RelationCombineInPatch)

data/lib/active_record_relation_in/where_clause/where_clause_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationIn
+  module WhereClause
+    module WhereClausePatch
+      def combine_with_in
+        ActiveRecordRelationIn::WhereClause::CombineWithInRelation.new(@predicates)
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordRelationIn::WhereClause::WhereClausePatch)

data/lib/active_record_relation_in.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "active_record_relation_in/version"
+
+require "active_record"
+
+module ActiveRecordRelationIn
+  extend ActiveSupport::Autoload
+
+  AR_VERSION_GTE_6_1 = Gem::Requirement.new(">= 6.1").satisfied_by?(ActiveRecord.gem_version)
+
+  module WhereClause
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :RelationPatch
+      autoload :WhereClausePatch
+      autoload :CombineWithInRelation
+    end
+  end
+
+  def self.eager_load!
+    super
+    ActiveRecordRelationIn::WhereClause.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecordRelationIn.eager_load!
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: active_record_relation_in
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Olafur Arason
+bindir: bin
+cert_chain: []
+date: 2025-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Adds relation in functionality to Activerecord Postgres implementation
+email:
+- olafura@olafura.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/active_record_relation_in.rb
+- lib/active_record_relation_in/version.rb
+- lib/active_record_relation_in/where_clause/combine_with_in_relation.rb
+- lib/active_record_relation_in/where_clause/relation_patch.rb
+- lib/active_record_relation_in/where_clause/where_clause_patch.rb
+homepage: https://github.com/olafura/active_record_relation_in
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Adds relation in functionality to Activerecord Postgres implementation
+test_files: []