pg_any_where 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a825cb6b120563bf415db84e4796acd7c4d5e370e5bf617d4b034f0721bf315a
+  data.tar.gz: 7f3fd236b46cd43e9721bdc8eb276056e3045f9793d6c8356e9c30683e202d65
+SHA512:
+  metadata.gz: 97649e2bc9817fed522c8f90e2604489b7f09a8678776caa7ccaad0ef578ab43c463dcb6a2abe051ae2cf9320a1284f35a925d5367644034da0f80c96cce6bfd
+  data.tar.gz: '08b888d8b14851f5e4ef839ef9201931078601fdfe773349ea872fb552b8a3651f94f106673dc46f52d2b9468e88fe2add8fad3da10ab384adfdee7294f7cd61'

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-26
+
+### Added
+- Initial release.
+- Rewrites `WHERE column IN (…)` to `WHERE column = ANY($1::type[])`.
+- Rewrites `WHERE column NOT IN (…)` to `WHERE column != ALL($1::type[])`.
+- Handles empty-array edge cases: `ANY(ARRAY[]::type[])` / `!= ALL(ARRAY[]::type[])`.
+- Block-style `PgAnyWhere.configure` API.
+- ENV variable support: `PG_ANY_WHERE_ENABLED` and `PG_ANY_WHERE_MIN_ARRAY_SIZE`.
+- `min_array_size` threshold — fall back to IN for small arrays if desired.
+- Rails Railtie for zero-configuration setup.
+- RSpec test suite with SimpleCov coverage enforcement (≥ 95 %).
+
+[Unreleased]: https://github.com/aimanabutalaah/pg_any_where/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/aimanabutalaah/pg_any_where/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aiman Abutalaah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+# pg_any_where
+
+[![Gem Version](https://badge.fury.io/rb/pg_any_where.svg)](https://rubygems.org/gems/pg_any_where)
+[![CI](https://github.com/aimanabutalaah/pg_any_where/actions/workflows/ci.yml/badge.svg)](https://github.com/aimanabutalaah/pg_any_where/actions)
+[![Coverage](https://img.shields.io/badge/coverage-95%25%2B-brightgreen)]()
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.txt)
+
+> **One gem. One bind parameter. Zero plan-cache pollution.**
+
+`pg_any_where` patches ActiveRecord so that `where(column: array)` emits
+PostgreSQL's array operators instead of `IN (…)`:
+
+```sql
+-- Before (standard ActiveRecord)
+SELECT * FROM widgets WHERE id IN ($1, $2, $3)
+
+-- After (pg_any_where)
+SELECT * FROM widgets WHERE id = ANY($1::integer[])
+```
+
+A 1 000-element array still produces **a single bind parameter**, keeping your
+prepared-statement cache sane and `pg_stat_statements` readable.
+
+---
+
+## Why?
+
+PostgreSQL's query planner caches plans keyed on the *shape* of a prepared
+statement, not its bind values. A standard `IN ($1, $2, …)` generates a new
+cache entry for *every distinct array length*, causing:
+
+- plan-cache bloat
+- `pg_stat_statements` pollution (thousands of near-identical rows)
+- occasional re-planning overhead on busy servers
+
+`= ANY($1::type[])` fixes all three: **one shape, one plan, cached forever**.
+
+> Further reading: [rails/rails#49388](https://github.com/rails/rails/pull/49388)
+
+### Empty-array edge cases
+
+| Standard ActiveRecord | `pg_any_where` |
+|---|---|
+| `WHERE 1=0` (empty `IN`) | `WHERE col = ANY(ARRAY[]::integer[])` |
+| `WHERE 1=1` (empty `NOT IN`) | `WHERE col != ALL(ARRAY[]::integer[])` |
+
+The footguns are gone. Empty arrays behave correctly and symmetrically.
+
+---
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "pg_any_where"
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+### Requirements
+
+| Dependency | Version |
+|---|---|
+| Ruby | ≥ 3.0 |
+| ActiveRecord | ≥ 6.1 |
+| PostgreSQL adapter (`pg`) | ≥ 1.2 |
+
+---
+
+## Usage
+
+### Rails (automatic)
+
+The gem ships a **Railtie** — no initializer code required. Simply add it to
+your `Gemfile` and restart your server. Done.
+
+To verify it is active:
+
+```ruby
+Widget.where(id: [1, 2, 3]).to_sql
+# => "SELECT ... WHERE \"widgets\".\"id\" = ANY($1::integer[])"
+```
+
+### Non-Rails
+
+```ruby
+require "pg_any_where"
+
+ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
+PgAnyWhere.patch!   # call once after connecting
+```
+
+---
+
+## Configuration
+
+### Block-style (recommended)
+
+```ruby
+# config/initializers/pg_any_where.rb
+PgAnyWhere.configure do |config|
+  # Disable the extension entirely (default: true).
+  config.enabled = true
+
+  # Only rewrite arrays with at least N elements; fall back to IN for smaller
+  # ones.  Useful if you want IN for 1- or 2-element lists where the planner
+  # might prefer an index seek with literal values.  (default: 0)
+  config.min_array_size = 0
+end
+```
+
+### Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `PG_ANY_WHERE_ENABLED` | `"true"` | Set to `"false"` to disable |
+| `PG_ANY_WHERE_MIN_ARRAY_SIZE` | `"0"` | Minimum array size to rewrite |
+
+ENV values act as **defaults** — an explicit Ruby config call always wins.
+
+---
+
+## SQL reference
+
+| ActiveRecord | SQL emitted |
+|---|---|
+| `where(col: [1, 2, 3])` | `col = ANY($1::integer[])` |
+| `where(col: [])` | `col = ANY(ARRAY[]::integer[])` |
+| `where.not(col: [1, 2])` | `col != ALL($1::integer[])` |
+| `where.not(col: [])` | `col != ALL(ARRAY[]::integer[])` |
+| `where(str_col: %w[a b])` | `str_col = ANY($1::character varying[])` |
+
+---
+
+## Compatibility notes
+
+### Ransack / raw Arel
+
+Ransack and manual `attribute.in([…])` calls build `Arel::Nodes::In` nodes
+whose values are already-quoted `Arel::Nodes::Node` objects. Re-casting those
+would produce an empty array, so **pg_any_where deliberately leaves them
+unchanged**. Your Ransack queries continue to work exactly as before.
+
+### `min_array_size`
+
+When `min_array_size > 0`, arrays shorter than the threshold fall back to the
+standard IN / NOT IN behaviour — including the `1=0` / `1=1` edge cases for
+empty arrays.
+
+---
+
+## Contributing
+
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/my-change`).
+3. Run the test suite (`bundle exec rspec`).
+4. Run the linter (`bundle exec rubocop`).
+5. Open a pull request.
+
+### Running tests locally
+
+```sh
+createdb pg_any_where_test
+DATABASE_URL=postgres://localhost/pg_any_where_test bundle exec rspec
+```
+
+Coverage is enforced at **≥ 95 %** via SimpleCov.
+
+---
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt).

data/lib/pg_any_where/arel_visitor.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Arel
+  module Visitors
+    # Arel visitor extension that rewrites IN / NOT IN predicates for PostgreSQL
+    # to use the array operators ANY and ALL.
+    #
+    # Prepended onto +Arel::Visitors::PostgreSQL+ via +PgAnyWhere.patch!+.
+    #
+    # SQL shape produced:
+    #
+    #   -- non-empty, inclusive
+    #   "table"."column" = ANY($1::integer[])
+    #
+    #   -- empty, inclusive  (no 1=0 footgun)
+    #   "table"."column" = ANY(ARRAY[]::integer[])
+    #
+    #   -- non-empty, exclusive
+    #   "table"."column" != ALL($1::integer[])
+    #
+    #   -- empty, exclusive  (no 1=1 footgun)
+    #   "table"."column" != ALL(ARRAY[]::integer[])
+    #
+    # rubocop:disable Naming/MethodName -- Arel visitor method names mirror node class names
+    module PgAnyWhereVisitor
+      private
+
+      # Rails 6.1+ emits HomogeneousIn for +where(col: [1, 2, 3])+ when all
+      # values are of the same Ruby class.
+      def visit_Arel_Nodes_HomogeneousIn(o, collector)
+        return super unless array_membership_applicable?(o.attribute, o.values)
+
+        emit_array_membership(
+          o.left,
+          o.casted_values,
+          o.type == :in,
+          o.attribute,
+          collector
+        )
+      end
+
+      # Handles +Arel::Nodes::In+ — including empty-array cases produced by
+      # +where(col: [])+ and heterogeneous arrays.
+      #
+      # NOTE: Ransack (and raw Arel +.in+ calls) build In nodes whose +right+
+      # side contains +Arel::Nodes::Node+ children (e.g. Quoted / Casted).
+      # Re-casting those is unsafe, so we leave them to the default visitor.
+      def visit_Arel_Nodes_In(o, collector)
+        attr   = o.left
+        values = o.right
+
+        if values.is_a?(Array) && convertible_in_list?(attr, values)
+          values.delete_if { |v| unboundable?(v) } unless values.empty?
+
+          return emit_array_membership(
+            attr,
+            cast_values_for_attribute(attr, values),
+            true,
+            attr,
+            collector
+          )
+        end
+
+        super
+      end
+
+      # Handles +Arel::Nodes::NotIn+ — used by +where.not(col: [1, 2])+.
+      def visit_Arel_Nodes_NotIn(o, collector)
+        attr   = o.left
+        values = o.right
+
+        if values.is_a?(Array) && convertible_in_list?(attr, values)
+          values.delete_if { |v| unboundable?(v) } unless values.empty?
+
+          return emit_array_membership(
+            attr,
+            cast_values_for_attribute(attr, values),
+            false,
+            attr,
+            collector
+          )
+        end
+
+        super
+      end
+
+      # -----------------------------------------------------------------------
+      # Predicate helpers
+      # -----------------------------------------------------------------------
+
+      def array_membership_applicable?(attribute, values)
+        ::PgAnyWhere.configuration.use_for_values?(values) &&
+          attribute.respond_to?(:type_caster)
+      end
+
+      # In nodes that contain Arel::Nodes::Node children (Ransack, raw Arel)
+      # must not be converted — re-casting those produces an empty array.
+      def convertible_in_list?(attribute, values)
+        array_membership_applicable?(attribute, values) &&
+          (values.empty? || values.none? { |v| v.is_a?(Arel::Nodes::Node) })
+      end
+
+      # -----------------------------------------------------------------------
+      # SQL emission
+      # -----------------------------------------------------------------------
+
+      def emit_array_membership(attribute, values, inclusive, bind_attribute, collector)
+        collector.preparable = false
+
+        visit(attribute, collector)
+        collector << (inclusive ? " = ANY(" : " != ALL(")
+        append_array_operand(bind_attribute, values, collector)
+        collector << ")"
+
+        collector
+      end
+
+      def append_array_operand(attribute, values, collector)
+        array_type = pg_oid_array_type(attribute)
+
+        if values.empty?
+          collector << "ARRAY[]::#{pg_array_sql_type(array_type)}"
+        else
+          array_data = array_type.serialize(values)
+          collector.add_binds(
+            [array_data],
+            bind_proc_for(attribute, array_type),
+            &bind_block
+          )
+        end
+      end
+
+      # -----------------------------------------------------------------------
+      # Type casting
+      # -----------------------------------------------------------------------
+
+      def cast_values_for_attribute(attribute, values)
+        return [] if values.empty?
+
+        type_caster = attribute.type_caster
+        values.filter_map do |raw|
+          type_caster.serialize(raw) if type_caster.serializable?(raw)
+        end
+      end
+
+      # -----------------------------------------------------------------------
+      # PostgreSQL OID helpers
+      # -----------------------------------------------------------------------
+
+      def pg_oid_array_type(attribute)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(
+          attribute.type_caster
+        )
+      end
+
+      def pg_array_sql_type(array_type)
+        "#{array_type.type}[]"
+      end
+
+      def bind_proc_for(attribute, array_type)
+        lambda do |value|
+          ActiveModel::Attribute.with_cast_value(attribute.name, value, array_type)
+        end
+      end
+    end
+    # rubocop:enable Naming/MethodName
+  end
+end

data/lib/pg_any_where/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PgAnyWhere
+  # Configuration for the PgAnyWhere gem.
+  #
+  # Set options via the block form:
+  #
+  #   PgAnyWhere.configure do |config|
+  #     config.enabled       = true
+  #     config.min_array_size = 2
+  #   end
+  #
+  # Or via environment variables (ENV values act as defaults when the attribute
+  # has not been explicitly set):
+  #
+  #   PG_ANY_WHERE_ENABLED        = "true" | "false"   (default: "true")
+  #   PG_ANY_WHERE_MIN_ARRAY_SIZE = integer             (default: "0")
+  #
+  class Configuration
+    # @return [Boolean, nil]
+    attr_writer :enabled
+
+    # @return [Integer, nil]
+    attr_writer :min_array_size
+
+    # Whether the extension is active.
+    #
+    # Explicit Ruby config takes precedence over the environment variable.
+    #
+    # @return [Boolean]
+    def enabled?
+      if @enabled.nil?
+        ENV.fetch("PG_ANY_WHERE_ENABLED", "true") == "true"
+      else
+        @enabled
+      end
+    end
+
+    # Minimum array size required before the ANY / ALL rewrite is applied.
+    # Arrays smaller than this threshold fall back to the standard IN / NOT IN.
+    #
+    # @return [Integer]
+    def min_array_size
+      @min_array_size || ENV.fetch("PG_ANY_WHERE_MIN_ARRAY_SIZE", "0").to_i
+    end
+
+    # Returns true when the rewrite should be applied to +values+.
+    #
+    # @param values [Object]
+    # @return [Boolean]
+    def use_for_values?(values)
+      enabled? &&
+        values.is_a?(Array) &&
+        values.size >= min_array_size
+    end
+
+    # Reset all settings back to defaults (reads ENV again).
+    def reset!
+      @enabled = nil
+      @min_array_size = nil
+      self
+    end
+  end
+end

data/lib/pg_any_where/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module PgAnyWhere
+  # Rails Railtie — automatically calls +PgAnyWhere.patch!+ during
+  # the +after_initialize+ phase so the patch lands after the database
+  # connection is established and the Arel visitor class is fully loaded.
+  class Railtie < Rails::Railtie
+    initializer "pg_any_where.patch_arel_visitor", after: :initialize_database do
+      PgAnyWhere.patch!
+    end
+  end
+end

data/lib/pg_any_where/version.rb

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

data/lib/pg_any_where.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "pg_any_where/version"
+require "pg_any_where/configuration"
+require "pg_any_where/arel_visitor"
+
+# PgAnyWhere rewrites ActiveRecord array-where conditions to use PostgreSQL's
+# ANY / ALL operators instead of IN / NOT IN.
+#
+# == Quick start (non-Rails)
+#
+#   require "pg_any_where"
+#   PgAnyWhere.patch!
+#
+# == Configuration
+#
+#   PgAnyWhere.configure do |config|
+#     config.enabled        = true   # or set ENV["PG_ANY_WHERE_ENABLED"]
+#     config.min_array_size = 2      # or set ENV["PG_ANY_WHERE_MIN_ARRAY_SIZE"]
+#   end
+#
+# == Rails
+#
+# No manual setup needed — the Railtie handles everything automatically.
+#
+module PgAnyWhere
+  class Error < StandardError; end
+
+  class << self
+    # Returns the global +Configuration+ instance.
+    #
+    # @return [PgAnyWhere::Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the global +Configuration+ for block-style setup.
+    #
+    # @yieldparam config [PgAnyWhere::Configuration]
+    def configure
+      yield configuration
+    end
+
+    # Patches +Arel::Visitors::PostgreSQL+ with the ANY / ALL rewrite logic.
+    #
+    # Idempotent — safe to call multiple times.
+    #
+    # @raise [PgAnyWhere::Error] if +Arel::Visitors::PostgreSQL+ is not defined
+    def patch!
+      return if @patched
+
+      unless defined?(Arel::Visitors::PostgreSQL)
+        raise Error, "Arel::Visitors::PostgreSQL is not defined. " \
+                     "Ensure activerecord-postgresql-adapter is loaded before calling PgAnyWhere.patch!"
+      end
+
+      Arel::Visitors::PostgreSQL.prepend(Arel::Visitors::PgAnyWhereVisitor)
+      @patched = true
+    end
+
+    # Returns +true+ after +patch!+ has been called successfully.
+    #
+    # @return [Boolean]
+    def patched?
+      @patched == true
+    end
+
+    # Shorthand for +PgAnyWhere.configuration.enabled?+.
+    #
+    # @return [Boolean]
+    def enabled?
+      configuration.enabled?
+    end
+
+    # Resets all configuration and the patched flag.
+    # Primarily used in tests.
+    #
+    # @return [void]
+    def reset!
+      @configuration = nil
+      # NOTE: we cannot un-prepend a module, so @patched is intentionally NOT
+      # reset here — calling patch! again would attempt a second prepend.
+      self
+    end
+  end
+end
+
+require "pg_any_where/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: pg_any_where
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aiman Abutalaah
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.26'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: |
+  pg_any_where patches Arel so that `where(column: array)` emits
+  `column = ANY($1::type[])` instead of `column IN ($1, $2, …)`.
+
+  This yields a stable prepared-statement shape (one bind parameter regardless
+  of array size), better PostgreSQL plan cache utilisation, and cleaner
+  pg_stat_statements output.  Empty arrays are handled correctly without the
+  `1=0` / `1=1` footguns.
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/pg_any_where.rb
+- lib/pg_any_where/arel_visitor.rb
+- lib/pg_any_where/configuration.rb
+- lib/pg_any_where/railtie.rb
+- lib/pg_any_where/version.rb
+homepage: https://github.com/aimanabutalaah/pg_any_where
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aimanabutalaah/pg_any_where
+  source_code_uri: https://github.com/aimanabutalaah/pg_any_where
+  changelog_uri: https://github.com/aimanabutalaah/pg_any_where/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/aimanabutalaah/pg_any_where/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.21
+signing_key:
+specification_version: 4
+summary: Rewrite ActiveRecord array-where to PostgreSQL ANY / ALL operators
+test_files: []