gql_serializer 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d8e3d8ba95425285d54b5e60ef3d871964b9753888a0142234ab5e2b3946062
+  data.tar.gz: 7870f9feb370d956d6e556f10e5542c108341d83a20f81e2faa77beceee4a21a
+SHA512:
+  metadata.gz: 1c741e6372a5c1a4e970de523867b798a775559e21815ca4e8995bbb8c1b5832f1ab725e29b2fa02fe6cd4fae28f166cf91308ef42993cb29008558afa1f7e81
+  data.tar.gz: 8cb2f9357675f3abeaa3a3bd1d21aae86c7adca3f3c44942bf4b0446785e26a4a4ad84435066fd241452733da5340739d8620d12753c47eed06f51e6d2422010

data/.github/workflows/ruby.yml

@@ -0,0 +1,33 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@21351ecc0a7c196081abca5dc55b08f085efe09a
+      with:
+        ruby-version: 2.6
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: rspec

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.idea
+.byebug_history
+test.db

data/.rspec

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

data/.ruby-version

@@ -0,0 +1 @@
+2.6.5

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.6
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gql_serializer.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    gql_serializer (2.2.0)
+      activerecord (>= 5.2, < 8.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.5)
+      activesupport (= 6.1.5)
+    activerecord (6.1.5)
+      activemodel (= 6.1.5)
+      activesupport (= 6.1.5)
+    activesupport (6.1.5)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    sqlite3 (1.4.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.5.4)
+
+PLATFORMS
+  ruby
+  x64-mingw32
+
+DEPENDENCIES
+  gql_serializer!
+  pry (~> 0.13.1)
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  sqlite3 (~> 1.4.2)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Andrew Scullion
+
+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,146 @@
+# GqlSerializer
+
+GqlSerializer is a gem that makes it easy to serialize ActiveRecord objects into json using a short syntax similar to GraphQL instead of the more verbose syntax used by the `as_json` method.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gql_serializer'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install gql_serializer
+
+## Basic Usage
+
+Say you have the following `User` class
+
+```ruby
+class User < ActiveRecord::Base
+  attribute :email_address, :string
+  attribute :name, :string
+  def encoded_id
+    "User-#{id}"
+  end
+end
+```
+
+and you create a user
+
+```ruby
+user = User.create(name: 'Test User', email_address: 'user@test.com')
+```
+
+You can call `as_gql` with no arguments to get:
+
+```ruby
+user.as_gql
+=> {
+  "id"=>1,
+  "name"=>"Test User",
+  "email_address"=>"user@test.com"
+}
+```
+
+By default, all attributes are included in the serialized form but you can create you want with the right arguments and include methods. 
+
+```ruby
+user.as_gql('name encoded_id')
+=> {
+  "name" => "Test User",
+  "encoded_id" => "User-1"
+}
+```
+
+## Advanced Usage
+
+Here's where the library becomes more powerful. The GraphQL-esque syntax allows for aliasing and digging into nested objects.
+
+```ruby
+class User < ActiveRecord::Base
+  attribute :email_address, :string
+  attribute :name, :string
+  has_many :orders
+  def encoded_id
+    "User-#{id}"
+  end
+end
+
+class Order < ActiveRecord::Base
+  belongs_to :user
+  attribute :total, :float
+  attribute :placed_at, :date_time
+end
+
+user = User.create(name: 'Test User', email_address: 'user@test.com')
+order = Order.create(user: user, total: 3.50, placed_at: DateTime.now)
+
+user.as_gql('name orders')
+=> {
+  "name" => "Test User",
+  "orders" => [{
+    "id" => 1,
+    "total" => 3.5,
+    "placed_at" => "2020-12-23T08:30:00Z"
+  }]
+}
+
+order.as_gql('user { email_address encoded_id:real_id }')
+=> {
+  "id" => 1,
+  "total" => 3.5,
+  "placed_at" => "2020-12-23T08:30:00Z",
+  "user" => {
+    "email_address" => "user@test.com",
+    "real_id" => "User-1"
+  }
+}
+```
+
+It's also possible to automatically convert the case of the keys into either camel case or snake case. We recommend that you configure this globally (see Configuration section) but it can be done using an optional second argument.
+
+```ruby
+user.as_gql('email_address name:full_name', {case: GqlSerializer::Configuration::CAMEL_CASE})
+=> {
+  "emailAddress" => "user@test.com",
+  "fullName" => "Test User"
+}
+```
+
+## Configuration
+
+In a Rails application, the configuration can be added to an initializer in `config/initalizers/gql_serializer.rb`. The following is the default configuration (no change):
+
+```ruby
+GqlSerializer.configure do |config|
+  # no case conversion
+  config.case = GqlSerializer::Configuration::NONE_CASE 
+  # set to true to avoid additional query in some cases. 
+  # The default of false avoids a potential breaking change from version 2.1 to 2.2
+  config.preload = false 
+end
+```
+
+The options for `case` are: `NONE_CASE, CAMEL_CASE, SNAKE_CASE`.
+
+## 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 tags, 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/TheDro/gql_serializer.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gql_serializer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gql_serializer.gemspec

@@ -0,0 +1,36 @@
+require_relative 'lib/gql_serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gql_serializer"
+  spec.version       = GqlSerializer::VERSION
+  spec.authors       = ["Andrew Scullion"]
+  spec.email         = ["andrewsc32@protonmail.com"]
+
+  spec.summary       = %q{A gem that adds `as_gql` to easily serialize ActiveRecord objects}
+  spec.description   = %q{A gem that adds `as_gql` to easily serialize ActiveRecord objects}
+  spec.homepage      = "https://github.com/TheDro/gql_serializer"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.1")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/TheDro/gql_serializer"
+  spec.metadata["changelog_uri"] = "https://github.com/TheDro/gql_serializer"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.13.1"
+  spec.add_development_dependency "sqlite3", "~> 1.4.2"
+
+  spec.add_runtime_dependency "activerecord", ">= 5.2", "< 8.0"
+end

data/lib/gql_serializer/configuration.rb

@@ -0,0 +1,30 @@
+
+
+module GqlSerializer
+  class Configuration
+    CAMEL_CASE = :camel
+    SNAKE_CASE = :snake
+    NONE_CASE = :none
+    SUPPORTED_CASES = [CAMEL_CASE, SNAKE_CASE, NONE_CASE]
+
+    def initialize
+      reset
+    end
+
+    attr_reader :case, :preload
+
+    def case=(value)
+      raise "Specified case '#{value}' is not supported" unless SUPPORTED_CASES.include?(value)
+      @case = value
+    end
+
+    def reset
+      @case = NONE_CASE
+      @preload = false # Default will be true in version 3+
+    end
+
+    def to_h
+      {case: @case}
+    end
+  end
+end

data/lib/gql_serializer/extensions.rb

@@ -0,0 +1,52 @@
+require "active_record"
+
+module GqlSerializer
+  module Array
+    def as_gql(query = nil)
+      map { |v| v.as_gql(query) }
+    end
+  end
+
+  module Relation
+    def as_gql(query = nil, options = {})
+      options_with_defaults = GqlSerializer.configuration.to_h.merge(options)
+      query_hasharray = query ? GqlSerializer.parse_query(query) : []
+      include_hasharray = GqlSerializer.query_include(self.model, query_hasharray)
+      records = self.includes(include_hasharray).records
+      GqlSerializer.serialize(records, query_hasharray, options_with_defaults)
+    end
+  end
+
+  module ActiveRecord
+    def self.as_gql(query = nil, options = {})
+      self.all.as_gql(query, options)
+    end
+
+    def as_gql(query = nil, options = {})
+      options_with_defaults = GqlSerializer.configuration.to_h.merge(options)
+      query_hasharray = query ? GqlSerializer.parse_query(query) : []
+      include_hasharray = GqlSerializer.query_include(self.class, query_hasharray)
+      if options_with_defaults[:preload]
+        GqlSerializer._preload([self], include_hasharray)
+        GqlSerializer.serialize(self, query_hasharray, options_with_defaults)
+      else
+        record = include_hasharray.empty? ? self : self.class.where(id: self).includes(include_hasharray).first
+        GqlSerializer.serialize(record, query_hasharray, options_with_defaults)
+      end
+    end
+  end
+
+  def self._preload(records, include_hasharray)
+    if ::ActiveRecord::VERSION::MAJOR >= 7
+      ::ActiveRecord::Associations::Preloader.
+        new(records: records, associations: include_hasharray).call
+    else
+      ::ActiveRecord::Associations::Preloader.
+        new.preload(records, include_hasharray)
+    end
+  end
+end
+
+ActiveRecord::Base.include GqlSerializer::ActiveRecord
+ActiveRecord::Relation.include GqlSerializer::Relation
+Array.include GqlSerializer::Array

data/lib/gql_serializer/version.rb

@@ -0,0 +1,3 @@
+module GqlSerializer
+  VERSION = "2.2.0"
+end

data/lib/gql_serializer.rb

@@ -0,0 +1,178 @@
+require "gql_serializer/version"
+require "gql_serializer/extensions"
+require "gql_serializer/configuration"
+
+
+module GqlSerializer
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+
+  def self.parse_query(input)
+    query = input.dup
+    query.strip!
+    query.gsub!(/[\r\n\t ]+/, ' ')
+    query.gsub!(/\{ /, '{')
+    query.gsub!(/ }/, '}')
+
+    result, _ = self.parse_it(query)
+    result
+  end
+
+  def self.query_include(model, hasharray)
+    include_array = []
+    relations = model.reflections
+    hasharray.each do |element|
+      if element.is_a? String
+        key = element.split(':')[0]
+        include_array.push(key) if relations[key]
+      elsif element.is_a? Hash
+        key = element.keys.first.split(':')[0]
+        relation_model = model.reflections[key].klass
+        relation_hasharray = self.query_include(relation_model, element.values.first)
+        if relation_hasharray.empty?
+          include_array.push(key)
+        else
+          include_array.push({key => relation_hasharray})
+        end
+      end
+    end
+    include_array
+  end
+
+  # example hasharray = ["id", "name", "tags", { "panels" => ["id", { "cards" => ["content"] }] }]
+  def self.serialize(records, hasharray, options, instructions = {})
+
+    if records.nil?
+      return nil
+    end
+
+
+    if records.respond_to? :map
+      return records.map do |record|
+        self.serialize(record, hasharray, options, instructions)
+      end
+    end
+    record = records
+
+    id = "#{record.class}, #{hasharray}"
+    instruction = instructions[id]
+    if (!instruction)
+      instruction = {klass: record.class, hasharray: hasharray, relations: [], attributes: []}
+      instructions[id] = instruction
+
+
+      model = record.class
+      all_relations = model.reflections.keys
+
+      relations = hasharray.filter do |relation|
+        next true if !relation.is_a?(String)
+
+        key, alias_key = relation.split(':')
+
+        all_relations.include?(key)
+      end
+
+      attributes = hasharray - relations
+      attributes = model.attribute_names if attributes.empty?
+
+      attributes.each do |attribute|
+        key, alias_key = attribute.split(':')
+        alias_key = apply_case(alias_key || key, options[:case])
+
+        instruction[:attributes].push({key: key, alias_key: alias_key})
+      end
+
+      relations.each do |relation|
+        if relation.is_a? String
+          key, alias_key = relation.split(':')
+          alias_key = apply_case(alias_key || key, options[:case])
+
+          instruction[:relations].push({key: key, alias_key: alias_key, hasharray: []})
+        else
+          key, alias_key = relation.keys.first.split(':')
+          alias_key = apply_case(alias_key || key, options[:case])
+
+          instruction[:relations].push({key: key, alias_key: alias_key, hasharray: relation.values.first})
+        end
+      end
+    end
+
+    hash = {}
+    instruction[:attributes].each do |attribute|
+      hash[attribute[:alias_key]] = coerce_value(record.public_send(attribute[:key]))
+    end
+    instruction[:relations].each do |relation|
+      relation_records = record.public_send(relation[:key])
+      hash[relation[:alias_key]] = self.serialize(relation_records, relation[:hasharray], options, instructions)
+    end
+
+    hash
+  end
+
+  def self.coerce_value(value)
+    return value.to_f if value.is_a? BigDecimal
+    return value.new_offset(0).strftime("%FT%TZ") if value.is_a? DateTime
+    return value.utc.iso8601 if value.is_a? Time
+    value
+  end
+
+
+  private
+
+  def self.apply_case(key, key_case)
+    case key_case
+    when Configuration::CAMEL_CASE
+      result = key.camelize
+      result[0] = result[0].downcase
+    when Configuration::SNAKE_CASE
+      result = key.underscore
+    else
+      result = key
+    end
+
+    result
+  end
+
+  def self.parse_it(query)
+    result = []
+    while query&.length&.> 0
+      if query[0] == ' '
+        query.strip!
+        next
+      elsif query[0] == '}'
+        return result, query[1..-1]
+      end
+
+      next_key = query[/[_a-zA-Z0-9:]+/]
+      query = query[next_key.length..-1]
+      query.strip!
+
+      if query.nil? || query.empty? || query[0].match?(/[_a-zA-Z0-9:]/)
+        result.push(next_key)
+
+      elsif query&.[](0) == '{'
+        query = query[1..-1]
+        obj, query = parse_it(query)
+        result.push(next_key => obj)
+
+      elsif query[0] == '}'
+        result.push(next_key)
+        return result, query[1..-1]
+
+      else
+        raise "unsupported character '#{query[0]}'"
+
+      end
+    end
+    return result, nil
+  end
+
+
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: gql_serializer
+version: !ruby/object:Gem::Version
+  version: 2.2.0
+platform: ruby
+authors:
+- Andrew Scullion
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: A gem that adds `as_gql` to easily serialize ActiveRecord objects
+email:
+- andrewsc32@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- gql_serializer.gemspec
+- lib/gql_serializer.rb
+- lib/gql_serializer/configuration.rb
+- lib/gql_serializer/extensions.rb
+- lib/gql_serializer/version.rb
+homepage: https://github.com/TheDro/gql_serializer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TheDro/gql_serializer
+  source_code_uri: https://github.com/TheDro/gql_serializer
+  changelog_uri: https://github.com/TheDro/gql_serializer
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: A gem that adds `as_gql` to easily serialize ActiveRecord objects
+test_files: []