ar-query-matchers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac905a2afca1579c9f829cb80ec5ea9db151311b7970e3a35f90528d0d9524b0
+  data.tar.gz: 5f1413a65d8276a0b282070be3d86f8a910224e51ac8fff893d3882c62986f25
+SHA512:
+  metadata.gz: 8c76ea6089d6e15a9ae2dcd9d07319756caa09d36d3645373a5362b04c677c67432305cd9598368231aaacd872604d73df20ca5c93c4d9e2bcd92ceea1860e90
+  data.tar.gz: ba4fb57beaf019f17ac41fbc66cb974bcb76616db0d0b5ce1a3028e87b66d8cf2f6b954342ee59ca52162debb6e4cf7478ae41266f0fad53c353437fea3849d8

data/README.md

@@ -0,0 +1,91 @@
+## AR Query Matchers
+
+These RSpec matchers allows guarding against N+1 queries by specifying
+exactly how many queries we expect each of our models to perform.
+
+They also help us reason about the type of record interactions happening in a block of code.
+
+This pattern is a based on how Rails itself tests queries:
+https://github.com/rails/rails/blob/ac2bc00482c1cf47a57477edb6ab1426a3ba593c/activerecord/test/cases/test_case.rb#L104-L141
+
+This module defines a few categories of matchers:
+- **Create**: Which models are created during a block
+- **Load**: Which models are fetched during a block
+- **Update**: Which models are updated during a block
+
+Each matcher category includes 3 assertions, for example, for the Load category, you could use the following assertions:
+- **only_load_models**: Strict assertion, not other query is allowed.
+- **not_load_models**: No models are allowed to be loaded.
+- **load_models**: Inclusion, other models are allowed to be loaded if not specified in the assertion.
+
+
+**For example:** 
+
+The following spec will pass only if there are exactly 4 SQL SELECTs that
+load User records (and 1 for Address, 1 for Payroll) _and_ no other models
+perform any SELECT queries.
+```ruby
+expect { some_code() }.to only_load_models(
+  'User' => 4,
+  'Address' => 1,
+  'Payroll' => 1,
+)
+```
+
+The following spec will pass only if there are exactly no select queries.
+```ruby
+expect { some_code() }.to not_load_models
+```
+
+The following spec will pass only if there are exactly 4 SQL SELECTs that
+load User records (and 1 for Address, 1 for Payroll).
+```ruby
+expect { some_code() }.to load_models(
+  'User' => 4,
+  'Address' => 1,
+  'Payroll' => 1,
+)
+```
+
+This will show some helpful output on failure:
+
+```
+Expected to run queries to load models exactly {"Address"=>1, "Payroll"=>1, "User"=>4} queries, got {"Address"=>1, "Payroll"=>1, "User"=>5}
+     Expectations that differed:
+         User - expected: 4, got: 5 (+1)
+
+     Source lines:
+     User loaded from:
+         4 call: /spec/controllers/employees_controller_spec.rb:128:in 'block (4 levels) in <top (required)>'
+         1 call: /app/models/user.rb:299
+```
+
+### High Level Design:
+The RSpec matcher delegates to the query counters, asserts expectations and formats error messages to provide meaningful failures.  
+ 
+ 
+The matchers are pretty simple, and delegate instrumentation into specialized QueryCounter classes.
+The QueryCounters are different classes instruments a ruby block by listening on all sql, parsing the queries and returning structured data describing the interactions.
+
+```                
+  ┌────────────────────────────────────────────────────────────────────────────────────────┐
+┌─┤expect { Employee.create!() }.to only_create_models('Employee' => 1)                    │
+│ └────────────────────────────────────────────────────────────────────────────────────────┘
+└▶┌────────────────────────────────────────────────────────────────────────────────────────┐
+┌─┤Queries::CreateCounter.instrument { Employee.create!() } => QueryStats                  │
+│ └────────────────────────────────────────────────────────────────────────────────────────┘
+└▶┌────────────────────────────────────────────────────────────────────────────────────────┐
+  │QueryCounter.new(CreateQueryFilter.new).instrument { Employee.create!() } => QueryStats │
+  └────────────────────────────────────────────────────────────────────────────────────────┘                                                                
+```
+
+For more information, see:
+1. `ArQueryMatchers::Queries::QueryCounter`
+2. `ArQueryMatchers::Queries::CreateCounter`
+3. `ArQueryMatchers::Queries::LoadCounter`
+4. `ArQueryMatchers::Queries::UpdateCounter`
+
+### Known problems
+- The Rails 4 `ActiveRecord::Base#pluck` method doesn't issue a
+`Load` or `Exists` named query and therefore we don't capture the counts with
+this tool. This may be fixed in Rails 5/6.

data/lib/ar_query_matchers.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'ar_query_matchers/queries/create_counter'
+require 'ar_query_matchers/queries/load_counter'
+require 'ar_query_matchers/queries/update_counter'
+
+module ArQueryMatchers
+  module ArQueryMatchers
+    module CreateModels
+      # The following will succeed:
+      #    expect {
+      #       WcRiskClass.create
+      #       WcRiskClass.create
+      #       Company.last
+      #    }.to only_create_models(
+      #       'WcRiskClass' => 2,
+      #    )
+      #
+      RSpec::Matchers.define(:only_create_models) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::CreateCounter.instrument(&block)
+          expected == @query_stats.query_counts
+        end
+
+        def failure_text
+          expectation_failed_message('create')
+        end
+      end
+
+      # The following will not succeed because the code creates models:
+      #
+      #    expect {
+      #       WcRiskClass.create
+      #       WcRiskClass.create
+      #       Company.last
+      #    }.to not_create_any_models
+      #
+      RSpec::Matchers.define(:not_create_any_models) do
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::CreateCounter.instrument(&block)
+          @query_stats.query_counts.empty?
+        end
+
+        def failure_text
+          no_queries_fail_message('create')
+        end
+      end
+    end
+
+    module LoadModels
+      # The following will fail because the call to `User` is not expected, even
+      # though the Payroll count is correct:
+      #
+      #    expect {
+      #       Payroll.count
+      #       Payroll.count
+      #       User.count
+      #    }.to only_load_models(
+      #       'Payroll' => 2,
+      #    )
+      #
+      # The following will succeed because the counts are exact:
+      #
+      #    expect {
+      #       Payroll.count
+      #       Payroll.count
+      #       User.count
+      #    }.to only_load_models(
+      #       'Payroll' => 2,
+      #       'User' => 1,
+      #    )
+      #
+      RSpec::Matchers.define(:only_load_models) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::LoadCounter.instrument(&block)
+          expected == @query_stats.query_counts
+        end
+
+        def failure_text
+          expectation_failed_message('load')
+        end
+      end
+
+      RSpec::Matchers.define(:not_load_any_models) do
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::LoadCounter.instrument(&block)
+          @query_stats.query_counts.empty?
+        end
+
+        def failure_text
+          no_queries_fail_message('load')
+        end
+      end
+
+      # The following will succeed because `load_models` allows any value for
+      # models not specified:
+      #
+      #    expect {
+      #       Payroll.count
+      #       Payroll.count
+      #       User.count
+      #    }.to load_models(
+      #       'Payroll' => 2,
+      #    )
+      RSpec::Matchers.define(:load_models) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::LoadCounter.instrument(&block)
+          expected.each do |model_name, expected_count|
+            expect(expected_count).to eq @query_stats.query_counts[model_name]
+          end
+        end
+
+        def failure_text
+          expectation_failed_message('load')
+        end
+      end
+    end
+
+    class UpdateModels
+      # The following will succeed:
+      #
+      #    expect {
+      #       WcRiskClass.last.update_attributes(id: 9999)
+      #    }.to only_update_models(
+      #       'WcRiskClass' => 1,
+      #    )
+      #
+      RSpec::Matchers.define(:only_update_models) do |expected = {}|
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::UpdateCounter.instrument(&block)
+          expected == @query_stats.query_counts
+        end
+
+        def failure_text
+          expectation_failed_message('update')
+        end
+      end
+
+      # The following will not succeed because the code updates models:
+      #
+      #    expect {
+      #       WcRiskClass.last.update_attributes(id: 9999)
+      #    }.to not_update_any_models
+      #
+      RSpec::Matchers.define(:not_update_any_models) do
+        include MatcherConfiguration
+        include MatcherErrors
+
+        match do |block|
+          @query_stats = Queries::UpdateCounter.instrument(&block)
+          @query_stats.query_counts.empty?
+        end
+
+        def failure_text
+          no_queries_fail_message('update')
+        end
+      end
+    end
+
+    # Shared methods that are included in the matchers.
+    # They configure it and ensure we get consistent and human readable error messages
+    module MatcherConfiguration
+      def self.included(base)
+        if base.respond_to?(:failure_message)
+          base.failure_message do |_actual|
+            failure_text
+          end
+        else
+          base.failure_message_for_should do |_actual|
+            failure_text
+          end
+        end
+      end
+
+      def supports_block_expectations?
+        true
+      end
+    end
+
+    module MatcherErrors
+      # Show the difference between expected and actual values with one value
+      # per line. This is done by hand because as of this writing the author
+      # doesn't understand how RSpec does its nice hash diff printing.
+      def difference(keys)
+        max_key_length = keys.reduce(0) { |max, key| [max, key.size].max }
+
+        keys.map do |key|
+          left = expected.fetch(key, 0)
+          right = @query_stats.queries.fetch(key, {}).fetch(:count, 0)
+
+          diff = "#{'+' if right > left}#{right - left}"
+
+          "#{key.rjust(max_key_length, ' ')} – expected: #{left}, got: #{right} (#{diff})"
+        end.compact
+      end
+
+      def source_lines(keys)
+        line_frequency = @query_stats.query_lines_by_frequency
+        keys_with_source_lines = keys.select { |key| line_frequency[key].present? }
+        keys_with_source_lines.map do |key|
+          source_lines = line_frequency[key].sort_by(&:last).reverse # Most frequent on top
+          next if source_lines.blank?
+
+          [
+            "  #{key}"
+          ] + source_lines.map { |line, count| "    #{count} #{'call'.pluralize(count)}: #{line}" } + [
+            ''
+          ]
+        end
+      end
+
+      def no_queries_fail_message(crud_operation)
+        "Expected ActiveRecord to not #{crud_operation} any records, got #{@query_stats.query_counts}\n\nWhere unexpected queries came from:\n\n#{source_lines(@query_stats.query_counts.keys).join("\n")}"
+      end
+
+      def expectation_failed_message(crud_operation)
+        all_model_names = expected.keys + @query_stats.queries.keys
+        model_names_with_wrong_count = all_model_names.reject { |key| expected[key] == @query_stats.queries[key][:count] }.uniq
+        "Expected ActiveRecord to #{crud_operation} #{expected}, got #{@query_stats.query_counts}\nExpectations that differed:\n#{difference(model_names_with_wrong_count).join("\n")}\n\nWhere unexpected queries came from:\n\n#{source_lines(model_names_with_wrong_count).join("\n")}"
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/create_counter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative './query_counter'
+require_relative './table_name'
+require_relative './query_filter'
+
+module ArQueryMatchers
+  module Queries
+    # A specialized QueryCounter for "creates".
+    # It uses a simple regex to identify and parse sql INSERT queries.
+    # For more information, see the QueryCounter class.
+    class CreateCounter
+      def self.instrument(&block)
+        QueryCounter.new(CreateQueryFilter.new).instrument(&block)
+      end
+
+      class CreateQueryFilter < QueryFilter
+        # Matches unnamed SQL operations like the following:
+        # "INSERT INTO `company_approval_details` ..."
+        TABLE_NAME_SQL_PATTERN = /INSERT INTO [`"](?<table_name>[^`"]+)[`"]/.freeze
+
+        def filter_map(_name, sql)
+          # for inserts, name is always 'SQL', we have to rely on pattern matching the query string.
+          select_from_table = sql.match(TABLE_NAME_SQL_PATTERN)
+
+          TableName.new(select_from_table[:table_name]) if select_from_table
+        end
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/load_counter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative './query_counter'
+require_relative './table_name'
+require_relative './model_name'
+require_relative './query_filter'
+
+module ArQueryMatchers
+  module Queries
+    # A specialized QueryCounter for "loads".
+    # For more information, see the QueryCounter class.
+    class LoadCounter
+      def self.instrument(&block)
+        QueryCounter.new(LoadQueryFilter.new).instrument(&block)
+      end
+
+      class LoadQueryFilter < Queries::QueryFilter
+        # Matches named SQL operations like the following:
+        # 'User Load'
+        MODEL_LOAD_PATTERN = /\A(?<model_name>[\w:]+) (Load|Exists)\Z/.freeze
+
+        # Matches unnamed SQL operations like the following:
+        # "SELECT COUNT(*) FROM `users` ..."
+        MODEL_SQL_PATTERN = /SELECT .* FROM [`"](?<table_name>[^`"]+)[`"]/.freeze
+
+        def filter_map(name, sql)
+          # First check for a `SELECT * FROM` query that ActiveRecord has
+          # helpfully named for us in the payload
+          match = name.match(MODEL_LOAD_PATTERN)
+          return ModelName.new(match[:model_name]) if match
+
+          # Fall back to pattern-matching on the table name in a COUNT and looking
+          # up the table name from ActiveRecord's loaded descendants.
+          select_from_table = sql.match(MODEL_SQL_PATTERN)
+          TableName.new(select_from_table[:table_name]) if select_from_table
+        end
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/model_name.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  module Queries
+    # An instance of this class is one of the values that could be returned from the QueryFilter#filter_map.
+    # its accepts a name of an ActiveRecord model, for example: 'Company'.
+    class ModelName
+      attr_reader(:model_name)
+
+      def initialize(model_name)
+        @model_name = model_name
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/query_counter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  module Queries
+    # The QueryCounter instruments a ruby block and collect stats on the
+    # SQL queries performed during its execution.
+    #
+    # It's "generic" meaning it requires an instance of a QueryFilter to operate.
+    # The QueryFilter is an interface that both filters SQL statements and maps them to an ActiveRecord model, sort of a Enumerator#filter_map.
+    #
+    # This class is meant to be wrapped by another class that provides a concrete QueryFilter implementation.
+    # For example, you could implement a SelectQueryFilter using it:
+    # class SelectQueryCounter
+    #   class SelectFilter < Queries::QueryFilter
+    #     def extract(_name, sql)
+    #       select_from_table = sql.match(/SELECT .* FROM [`"](?<table_name>[^`"]+)[`"]/)
+    #       Queries::TableName.new(select_from_table[:table_name]) if select_from_table
+    #     end
+    #   end
+    #
+    #   def self.instrument(&block)
+    #     QueryCounter.new(SelectFilter.new).instrument(&block)
+    #   end
+    # end
+    #
+    # stats = SelectQueryCounter.instrument do
+    #   Company.first
+    #   Employee.last(100)
+    #   User.find(1)
+    #   User.find(2)
+    # end
+    #
+    # stats.query_counts == { 'Company' => 1, Employee => '1', 'User' => 2 }
+    class QueryCounter
+      class QueryStats
+        def initialize(queries)
+          @queries = queries
+        end
+
+        attr_reader(:queries)
+
+        # @return [Hash] of model name to query count, for example: { 'Company' => 5}
+        def query_counts
+          Hash[*queries.reduce({}) { |acc, (model_name, data)| acc.update model_name => data[:count] }.sort_by(&:first).flatten]
+        end
+
+        # @return [Hash] of line in the source code to its frequency
+        def query_lines_by_frequency
+          queries.reduce({}) do |lines, (model_name, data)|
+            frequencies = data[:lines].reduce(Hash.new { |h, k| h[k] = 0 }) do |freq, line|
+              freq.update line => freq[line] + 1
+            end
+            lines.update model_name => frequencies
+          end
+        end
+      end
+
+      def initialize(query_filter)
+        @query_filter = query_filter
+      end
+
+      # @param [block] block to instrument
+      # @return [QueryStats] stats about all the SQL queries executed during the block
+      def instrument(&block)
+        queries = Hash.new { |h, k| h[k] = { count: 0, lines: [] } }
+        ActiveSupport::Notifications.subscribed(to_proc(queries), 'sql.active_record', &block)
+        QueryStats.new(queries)
+      end
+
+      private
+
+      # The 'marginalia' gem adds a line from the backtrace to the SQL query in
+      # the form of a comment.
+      MARGINALIA_SQL_COMMENT_PATTERN = %r{/*line:(?<line>.*)'*/}.freeze
+      private_constant :MARGINALIA_SQL_COMMENT_PATTERN
+
+      def to_proc(queries)
+        lambda do |_name, _start, _finish, _message_id, payload|
+          return if payload[:cached]
+
+          # Given a `sql.active_record` event, figure out which model is being
+          # accessed. Some of the simpler queries have a :ame key that makes this
+          # really easy. Others require parsing the SQL by hand.
+          model_name = @query_filter.filter_map(payload[:name] || '', payload[:sql] || '')&.model_name
+
+          if model_name
+            comment = payload[:sql].match(MARGINALIA_SQL_COMMENT_PATTERN)
+            queries[model_name][:lines] << comment[:line] if comment
+            queries[model_name][:count] += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/query_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  module Queries
+    # An instance of this interface must be provided to the QueryCounter class.
+    # it allows one to customize which queries it wants to capture.
+    class QueryFilter
+      # @param _name [String] the name of the ActiveRecord operation (this is sometimes garbage)
+      # For example: "User Load"
+      #
+      # @param _sql [String] the sql query that was executed
+      # For example: "SELECT  `users`.* FROM `users` .."
+      #
+      # @return nil or an instance which responds to #model_name (see TableName or ModelName)
+      # By returning nil we omit the query
+      # By not returning nil, we are associating this query with a model_name.
+      def filter_map(_name, _sql)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/table_name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  module Queries
+    # An instance of this class is one of the values that could be returned from the QueryFilter#filter_map.
+    # its accepts a name of a table in the database, for example: 'companies'.
+    #
+    # #model_name would transform the table name ('companies') into the ActiveRecord model name ('Company').
+    # It relies on the class to be loaded in the global namespace, which should be the case if we issues a query through ActiveRecord.
+    class TableName
+      def initialize(table_name)
+        @table_name = table_name
+      end
+
+      def model_name
+        active_record_class_for_table(@table_name)&.name
+      end
+
+      private
+
+      # We recalculate this each time because new classes might get loaded between queries
+      def active_record_class_for_table(table_name)
+        # Retrieve all (known) subclasses of ActiveRecord::Base
+        klasses = ActiveRecord::Base.descendants.reject(&:abstract_class)
+
+        # Group them by their table_names
+        tables = klasses.each_with_object(Hash.new { |k, v| k[v] = [] }) do |klass, accumulator|
+          accumulator[klass.table_name] << klass
+        end
+        # Structure:
+        # { 'users' => [User, AtoUser],
+        #   'employees => [Employee, PandaFlows::StateFields] }
+
+        # Of all the models that share the same table name sort them by their
+        # relative ancestry and pick the one that all the rest inherit from
+        tables[table_name].min_by { |a, b| a.ancestors.include?(b) }
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/queries/update_counter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative './query_counter'
+require_relative './table_name'
+require_relative './query_filter'
+
+module ArQueryMatchers
+  module Queries
+    # A specialized QueryCounter for "updates".
+    # It uses a simple regex to identify and parse sql UPDATE queries.
+    # For more information, see the QueryCounter class.
+    class UpdateCounter
+      def self.instrument(&block)
+        QueryCounter.new(UpdateQueryFilter.new).instrument(&block)
+      end
+
+      class UpdateQueryFilter < QueryFilter
+        # Matches unnamed SQL operations like the following:
+        # "UPDATE `bank_account_verifications` ..."
+        TABLE_NAME_SQL_PATTERN = /UPDATE [`"](?<table_name>[^`"]+)[`"]/.freeze
+
+        def filter_map(_name, sql)
+          # for updates, name is always 'SQL', we have to rely on pattern matching on the query string instead.
+          select_from_table = sql.match(TABLE_NAME_SQL_PATTERN)
+          TableName.new(select_from_table[:table_name]) if select_from_table
+        end
+      end
+    end
+  end
+end

data/lib/ar_query_matchers/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ArQueryMatchers
+  VERSION = File.read(File.join(File.dirname(__FILE__), '../../VERSION')).chomp
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: ar-query-matchers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matan Zruya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: ''
+email:
+- mzruya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ar_query_matchers.rb
+- lib/ar_query_matchers/queries/create_counter.rb
+- lib/ar_query_matchers/queries/load_counter.rb
+- lib/ar_query_matchers/queries/model_name.rb
+- lib/ar_query_matchers/queries/query_counter.rb
+- lib/ar_query_matchers/queries/query_filter.rb
+- lib/ar_query_matchers/queries/table_name.rb
+- lib/ar_query_matchers/queries/update_counter.rb
+- lib/ar_query_matchers/version.rb
+homepage: https://github.com/Gusto/ar-query-matchers
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Gusto/ar-query-matchers
+  source_code_uri: https://github.com/Gusto/ar-query-matchers
+  changelog_uri: https://github.com/Gusto/ar-query-matchers
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []