active-query 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 94e95d436673389768c5ee9999d7b8d144a70a6b718411a24cdde34a5281cbba
+  data.tar.gz: c427212727750ff677b1200bf191e0abb531b428389028e53db74c162be847c7
+SHA512:
+  metadata.gz: f1422b5d9bcf688fe25affe8f87dc108341c53194f417e4ec9a10c86f67c37346d3cadfe369a5f54c9e118b3fd96033b43310f2f96c1f2c5095fa40390f3b96a
+  data.tar.gz: 2a77ffdf0ec0e257b121cec50ccc3113c9d43dde0202e37531ad56782aa963dd0de302932d3b683cb2167f9766e3f4636fba1be1fdfe3ad30e3027baf9e8cfd6

data/.byebug_history

@@ -0,0 +1,49 @@
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+subject
+c
+DummyModel.count
+c
+DummyModel.count
+c
+subject
+c
+ const_defined?(model_class_name)
+model_class_name
+n
+c
+DummyModel.create!(name: 'Dummy')
+c
+DummyModel.new
+DummyModel.class
+DummyModel
+c
+DummyModel.table_name
+DummyModel.class
+DummyModel
+DummyModel.create
+DummyModel.creat
+c
+model_name
+c
+model_name
+c
+@__model
+self.name
+self
+c
+self.class.name
+self.class
+self.name
+self
+c
+ActiveRecord::Base.connection

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# 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.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.1] - 2024-12-19
+
+### Added
+- Initial release of ActiveQuery gem
+- Query object DSL with `ActiveQuery::Base` module
+- Type validation for query arguments (String, Integer, Float, Boolean)
+- Support for optional arguments and default values
+- Custom scopes with `ActiveQuery::Scopes` module
+- Additional query operations: `gt`, `gteq`, `lt`, `lteq`, `like`, `start_like`, `end_like`
+- Resolver pattern support for complex queries
+- Conditional query building with `if` and `unless` methods
+- Automatic model inference from class names
+- ActiveRecord integration with Rails 6.1+ support
+- Comprehensive test suite with 100% code coverage
+- GitHub Actions CI/CD pipeline
+
+### Features
+- **Query Objects**: Create reusable query objects with clean DSL
+- **Type Safety**: Built-in argument validation
+- **Scopes**: Define custom scopes for queries
+- **Operations**: Extended query operations beyond standard ActiveRecord
+- **Resolvers**: Support complex query logic with resolver classes
+- **Conditional Logic**: Apply scopes conditionally with `if`/`unless`
+
+[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.0.1...HEAD
+[0.0.1]: https://github.com/matiasasis/active-query/releases/tag/v0.0.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Matias Asis
+
+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,208 @@
+# ActiveQuery
+
+ActiveQuery is a gem that helps you create query objects in a simple way. It provides a DSL to define queries and scopes for your query object, making it easier to organize and reuse complex database queries.
+
+## Features
+
+- **Query Objects**: Create reusable query objects with a clean DSL
+- **Type Validation**: Built-in argument type validation
+- **Scopes**: Define custom scopes for your queries
+- **Operations**: Additional query operations like `gt`, `lt`, `like`, etc.
+- **Resolvers**: Support for resolver pattern for complex queries
+- **ActiveRecord Integration**: Works seamlessly with ActiveRecord models
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active-query'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install active-query
+```
+
+## Usage
+
+### Basic Query Object
+
+Create a query object by including `ActiveQuery::Base`:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  
+  # The model is automatically inferred from the class name (User)
+  # Or you can explicitly set it:
+  # model_name 'User'
+  
+  query :by_email, 'Find users by email', { email: { type: String } } do |email:|
+    scope.where(email: email)
+  end
+  
+  query :active, 'Find active users' do
+    scope.where(active: true)
+  end
+end
+```
+
+### Using Query Objects
+
+```ruby
+# Find users by email
+users = UserQuery.by_email(email: 'john@example.com')
+
+# Find active users
+active_users = UserQuery.active
+
+# Chain queries
+active_users_with_email = UserQuery.active.by_email(email: 'john@example.com')
+```
+
+### Query Arguments with Types
+
+```ruby
+class ProductQuery
+  include ActiveQuery::Base
+  
+  query :by_price_range, 'Find products within price range', {
+    min_price: { type: Float },
+    max_price: { type: Float, optional: true },
+    include_tax: { type: ActiveQuery::Base::Boolean, default: false }
+  } do |min_price:, max_price:, include_tax:|
+    scope.where('price >= ?', min_price)
+         .then { |s| max_price ? s.where('price <= ?', max_price) : s }
+         .then { |s| include_tax ? s.where(tax_included: true) : s }
+  end
+end
+
+# Usage
+products = ProductQuery.by_price_range(min_price: 10.0, max_price: 100.0, include_tax: true)
+```
+
+### Custom Scopes
+
+Define reusable scopes within your query object:
+
+```ruby
+class OrderQuery
+  include ActiveQuery::Base
+  include ActiveQuery::Scopes
+  
+  scope :recent, -> { where('created_at > ?', 1.week.ago) }
+  scope :completed, -> { where(status: 'completed') }
+  
+  query :recent_completed, 'Find recent completed orders' do
+    scope.recent.completed
+  end
+end
+```
+
+### Operations
+
+ActiveQuery provides additional query operations:
+
+```ruby
+class UserQuery
+  include ActiveQuery::Base
+  
+  query :by_age_range, 'Find users by age range', {
+    min_age: { type: Integer, optional: true },
+    max_age: { type: Integer, optional: true }
+  } do |min_age:, max_age:|
+    scope.then { |s| min_age ? s.gteq(:age, min_age) : s }
+         .then { |s| max_age ? s.lteq(:age, max_age) : s }
+  end
+  
+  query :by_name, 'Find users by name pattern', { name: { type: String } } do |name:|
+    scope.like(:name, name)
+  end
+end
+```
+
+Available operations:
+- `gt(column, value)` - greater than
+- `gteq(column, value)` - greater than or equal
+- `lt(column, value)` - less than  
+- `lteq(column, value)` - less than or equal
+- `like(column, value)` - contains pattern
+- `start_like(column, value)` - starts with pattern
+- `end_like(column, value)` - ends with pattern
+
+### Resolvers
+
+For complex queries, you can use the resolver pattern:
+
+```ruby
+class UserStatsResolver < ActiveQuery::Resolver
+  def resolve(status: nil)
+    query = scope.joins(:orders)
+    query = query.where(status: status) if status
+    query.group(:id).having('COUNT(orders.id) > 5')
+  end
+end
+
+class UserQuery
+  include ActiveQuery::Base
+  
+  query :with_many_orders, 'Users with many orders', {
+    status: { type: String, optional: true }
+  }, resolver: UserStatsResolver
+end
+
+# Usage
+users = UserQuery.with_many_orders(status: 'active')
+```
+
+### Conditional Queries
+
+Use `if` and `unless` for conditional query building:
+
+```ruby
+class ProductQuery
+  include ActiveQuery::Base
+  
+  query :search, 'Search products', {
+    name: { type: String, optional: true },
+    category: { type: String, optional: true },
+    on_sale: { type: ActiveQuery::Base::Boolean, optional: true }
+  } do |name:, category:, on_sale:|
+    scope.if(name.present?, -> { where('name ILIKE ?', "%#{name}%") })
+         .if(category.present?, -> { where(category: category) })
+         .if(on_sale == true, -> { where('sale_price IS NOT NULL') })
+  end
+end
+```
+
+## Requirements
+
+- Ruby >= 2.6.0
+- ActiveRecord >= 6.1
+- ActiveSupport >= 6.1
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/matiasasis/active-query. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/active-query

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "active_query"

data/lib/active_query/resolver.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  class Resolver
+    attr_accessor :scope
+
+    def initialize(scope)
+      @scope = scope
+    end
+  end
+end

data/lib/active_query/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  VERSION = '0.0.1'
+end

data/lib/active_query.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_support'
+require 'active_support/concern'
+require_relative 'active_query/version'
+require_relative 'active_query/resolver'
+require_relative 'active_record_relation_extensions'
+
+module ActiveQuery
+  module Base
+    extend ::ActiveSupport::Concern
+
+    class Boolean; end
+
+    included do
+      infer_model
+      @__queries = []
+    end
+
+    class_methods do
+      def model_name(model_name)
+        classified_model_name = model_name.classify
+        model = classified_model_name.safe_constantize
+        raise NameError, "Model #{classified_model_name} not found" unless model
+        raise ArgumentError, 'Model should be an ActiveRecord::Base' unless model.ancestors.include?(ActiveRecord::Base)
+
+        @__model = model
+      end
+
+      def model
+        @__model
+      end
+
+      def scope
+        raise ArgumentError, "Model not defined. Add model_name('Your::Model') to your QueryObject" unless @__model
+
+        @__scope ||= begin
+          relation = @__model.all.extending(Operations)
+          relation = relation.extending(scopes_module_name.constantize) if const_defined?(scopes_module_name)
+          relation
+        end
+      end
+
+      # Will list all queries available on query object.
+      def queries
+        @__queries
+      end
+
+      def query(name, description, args_def_or_lambda = nil, lambda = nil, **kwargs)
+        raise ArgumentError, 'name must be present' unless name.present?
+
+        if args_def_or_lambda.is_a?(Hash)
+          if kwargs[:resolver].present?
+            query_with_resolver(name, description, args_def_or_lambda, **kwargs)
+          else
+            query_with_arguments(name, description, args_def_or_lambda, lambda)
+          end
+        elsif args_def_or_lambda.is_a?(Proc)
+          query_without_args(name, description, args_def_or_lambda)
+        elsif args_def_or_lambda.nil? && kwargs[:resolver].present?
+          query_with_resolver_without_out_args(name, description, **kwargs)
+        else
+          raise ArgumentError, 'Invalid query definition'
+        end
+      end
+
+      private
+
+      def scopes_module_name
+        "#{self}::Scopes"
+      end
+
+      def infer_model
+        model_class_name = self.name.sub(/::Query$/, '').classify
+        return unless const_defined?(model_class_name)
+
+        model = model_class_name.safe_constantize
+        return unless model.ancestors.include?(ActiveRecord::Base)
+
+        model_name(model_class_name)
+      end
+
+      def query_with_arguments(name, description, args_def, lambda)
+        register_query(name, description, args_def)
+
+        define_singleton_method(name) do |given_args|
+          given_args = validate_args(name, given_args, args_def)
+          lambda.call(**given_args)
+        end
+      end
+
+      def query_without_args(name, description, lambda)
+        register_query(name, description)
+        define_singleton_method(name) { lambda.call }
+      end
+
+      def query_with_resolver(name, description, args_def, **kwargs)
+        register_query(name, description, args_def)
+        resolver = kwargs[:resolver]
+        raise 'Invalid Resolver, must inherit from ActiveQuery::Resolvers::Base' unless resolver.ancestors.include?(ActiveQuery::Resolver)
+
+        define_singleton_method(name) do |given_args|
+          given_args = validate_args(name, given_args, args_def)
+          resolver.new(scope).resolve(**given_args)
+        end
+      end
+
+      def query_with_resolver_without_out_args(name, description, **kwargs)
+        register_query(name, description)
+        resolver = kwargs[:resolver]
+        raise 'Invalid Resolver, must inherit from ActiveQuery::Resolvers::Base' unless resolver.ancestors.include?(ActiveQuery::Resolver)
+
+        define_singleton_method(name) { resolver.new(scope).resolve }
+      end
+
+      def register_query(name, description, args_def = {})
+        # Validate optional and default are not present together
+        optional_and_default = args_def.select { |key, value| value[:optional] == true && value[:default].present? }
+        raise ArgumentError, "Optional and Default params can't be present together: #{optional_and_default.keys}" if optional_and_default.present?
+
+        # Will add all queries for further serving the method 'queries'
+        @__queries << { name:, description:, args_def: }.compact_blank
+      end
+
+      def validate_args(name, given_args, args_def)
+        # Validate if the given arguments are correct
+        raise ArgumentError, "Incorrect Params, must be called '.#{name}(#{args_def.keys.map { |p| "#{p}: value" }.join(', ')})' " unless given_args.is_a?(Hash)
+
+        non_optional_args = args_def.reject { |key, value| value[:optional] == true }
+        args_not_provided = non_optional_args.keys - given_args.keys
+
+        args_with_default_to_add = args_def.select { |key, value| value[:default].present? && args_not_provided.include?(key) }
+        given_args.merge!(args_with_default_to_add.map { |key, value| [key, value[:default]] }.to_h)
+
+        missing_args = non_optional_args.keys - given_args.keys
+        raise ArgumentError, "Params missing: #{missing_args}" unless missing_args.empty?
+
+        extra_params = given_args.keys - args_def.keys
+        raise ArgumentError, "Unknown params: #{extra_params}" unless extra_params.empty?
+
+        given_args.each do |given_arg|
+          given_arg_config = args_def[given_arg.first]
+          given_arg_type = given_arg_config[:type]
+          given_arg_name = given_arg.first
+          given_arg_value = given_arg.second
+
+          if given_arg_type == ActiveQuery::Base::Boolean
+            unless given_arg_value == true || given_arg_value == false
+              raise ArgumentError, ":#{given_arg_name} must be of type Boolean"
+            end
+          else
+            unless given_arg_value.instance_of?(given_arg_type)
+              raise ArgumentError, ":#{given_arg_name} must be of type #{given_arg_type}"
+            end
+          end
+        end
+
+        # Populates all the non optional non given arguments with nil.
+        not_given_args = args_def.keys - given_args.keys
+        given_args.merge(not_given_args.map { |key| [key, nil] }.to_h)
+      end
+    end
+
+    module Operations
+      def gt(col, val) = __operation(:gt, col, val)
+      def gteq(col, val) = __operation(:gteq, col, val)
+      def lt(col, val) = __operation(:lt, col, val)
+      def lteq(col, val) = __operation(:lteq, col, val)
+      def like(col, val) = __operation(:matches, col, "%#{val}%")
+      def start_like(col, val) = __operation(:matches, col, "#{val}%")
+      def end_like(col, val) = __operation(:matches, col, "%#{val}")
+      def __operation(op, col, val) = where(arel_table[col].send(op, val))
+    end
+  end
+
+  module Scopes
+    extend ActiveSupport::Concern
+
+    included do
+      @__scopes = []
+    end
+
+    class_methods do
+      attr_accessor :__scopes
+
+      def scope(name, lambda)
+        __scopes << [name, lambda]
+        define_method(name, &lambda)
+      end
+    end
+  end
+end

data/lib/active_record_relation_extensions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecordRelationExtensions
+  extend ActiveSupport::Concern
+
+  # Adds the `if` method to ActiveRecord::Relation
+  module ClassMethods
+    # `if` applies the given scope only if the condition is true.
+    #
+    # @param if_condition [Boolean] whether to apply the scope
+    # @param scope [Proc] a callable object representing the scope
+    # @return [ActiveRecord::Relation] the modified or original relation
+    def if(if_condition, scope)
+      return self unless if_condition
+
+      raise "Invalid Scope. Must provide a lambda '-> { your_scope(arg) }'" unless scope.is_a?(Proc)
+
+      merge(scope)
+    end
+
+    # `if` applies the given scope only if the condition is true.
+    #
+    # @param if_condition [Boolean] whether to apply the scope
+    # @param scope [Proc] a callable object representing the scope
+    # @return [ActiveRecord::Relation] the modified or original relation
+    def unless(unless_condition, scope)
+      return self if unless_condition
+
+      raise "Invalid Scope. Must provide a lambda '-> { your_scope(arg) }'" unless scope.is_a?(Proc)
+
+      merge(scope)
+    end
+  end
+end
+
+ActiveRecord::Relation.include(ActiveRecordRelationExtensions::ClassMethods)

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: active-query
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matias Asis
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-08-06 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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !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.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+description: ActiveQuery is a gem that helps you to create query objects in a simple
+  way. It provides a DSL to define queries and scopes for your query object.
+email:
+- matiasis.90@gmail.com
+executables:
+- active-query
+extensions: []
+extra_rdoc_files: []
+files:
+- ".byebug_history"
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/active-query
+- lib/active_query.rb
+- lib/active_query/resolver.rb
+- lib/active_query/version.rb
+- lib/active_record_relation_extensions.rb
+homepage: https://github.com/matiasasis/active-query
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/matiasasis/active-query
+  source_code_uri: https://github.com/matiasasis/active-query
+  bug_tracker_uri: https://github.com/matiasasis/active-query/issues
+  changelog_uri: https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md
+  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: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.15
+signing_key:
+specification_version: 4
+summary: ActiveQuery is a gem that helps you to create query objects in a simple way.
+test_files: []