database_recorder 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8b63b3fa1b57dd6c2c5cdf501af590f75a5fcb52c322bc4eee702c55026db6
-  data.tar.gz: f2753254f7c7d79ef0fd7dd65e3439197419ae01d96e4625eb3a9f4632835bd9
+  metadata.gz: 48d1f4f88105fa9ac49075181f90208ca051bec2273daaeaf77cca9ad2c1ed77
+  data.tar.gz: 9ef096a48a9a0dafd7bbab635a20805d4b5ec0f06710d9b596554a1f03016c8e
 SHA512:
-  metadata.gz: 343167b893fd491b57405ad465e1b835fcf077d3cc806a4c3a4e6ca7c1253e0967acca90760c30e395de30aa8529421305910f9714879f118892259acf03dbe7
-  data.tar.gz: a2f8defdbd1e9f251afd6c999077870689c20f9c7868cc5d01a2947ab63c3ee1eec2c5401b14eef1378e450dbeb2fb170f93d011e54f8c8e677c150394f0b024
+  metadata.gz: 177da34267bb1fb58fb1b99e68d68430f8d36822facffb9fcd42e2e024176bbfc7be4d57ef807ce834bf1522151255c1614e5a9bb73833d86b70eb502aac0a30
+  data.tar.gz: 43d907dd4dc7902280bb379a4ae20dadca9c89712e62a188be7609795efd0c87db968c0b938e303e1f3e38bf44e23d34ed91be567169e118b42b3c00bd7e212e

data/README.md

@@ -6,7 +6,7 @@
 [![Specs PostgreSQL](https://github.com/blocknotes/database_recorder/actions/workflows/specs_postgres.yml/badge.svg)](https://github.com/blocknotes/database_recorder/actions/workflows/specs_postgres.yml)
 
 Record database queries for testing and development purposes.
-Supports only RSpec at the moment. Store queries information on files or Redis.
+Store queries information on files or Redis.
 
 Main features:
 - store the history of the queries of a test when it run (for monitoring);
@@ -15,10 +15,16 @@ Main features:
 
 Sample output: [test.yml](extra/sample.yml)
 
+Creating an environment variable to enable it with RSpec:
+
+![image1](extra/image1.png)
+
 ## Install
 
+### With RSpec
+
 - Add to your Gemfile: `gem 'database_recorder', require: false` (:development, :test groups recommended)
-- Using RSpec, add in **rails_helper.rb**:
+- Add in **rails_helper.rb**:
 
 ```rb
 require 'database_recorder'
@@ -49,9 +55,20 @@ RSpec.configure do |config|
 end
 ```
 
-Using an environment variable to enable it:
+### With plain Ruby
 
-![image1](extra/image1.png)
+```rb
+DatabaseRecorder::Config.db_driver = :pg
+DatabaseRecorder::Core.setup
+DatabaseRecorder::Recording.new(options: { name: 'pg_file' }).tap do |recording|
+  pp recording.start do
+    PG.connect(DB_CONFIG).exec("INSERT INTO tags(name, created_at, updated_at) VALUES('tag1', NOW(), NOW())")
+    PG.connect(DB_CONFIG).exec("SELECT * FROM tags")
+  end
+end
+```
+
+Please check more [examples](examples).
 
 ## Config
 
@@ -61,7 +78,10 @@ Add to your _spec_helper.rb_:
 # Database driver to use: :active_record | :mysql2 | :pg
 DatabaseRecorder::Config.db_driver = :pg
 
-# To print the queries while executing the specs: false | true | :color
+# Log queries format (default: '[DB] %sql [%name]')
+DatabaseRecorder::Config.log_format = '>>> %name -- %sql'
+
+# To print/log the queries while executing the specs: false | true | :color
 DatabaseRecorder::Config.print_queries = true
 
 # Replay the recordings intercepting the queries
@@ -70,6 +90,12 @@ DatabaseRecorder::Config.replay_recordings = true
 # To store the queries: :file | :redis | nil
 DatabaseRecorder::Config.storage = :redis
 # nil to avoid storing the queries
+
+# File storage options
+DatabaseRecorder::Config.storage_options = { recordings_path: '/some/path' }
+
+# Redis storage options
+DatabaseRecorder::Config.storage_options = { connection: Redis.new }
 ```
 
 ## History of the queries

data/lib/database_recorder/active_record/recorder.rb

@@ -18,16 +18,16 @@ module DatabaseRecorder
         if Config.replay_recordings && Recording.from_cache
           Recording.push(sql: sql, binds: binds)
           data = Recording.cached_query_for(sql)
-          return yield if !data || !data['result'] # cache miss
+          return yield if !data || !data[:result] # cache miss
 
-          RecordedResult.new(data['result']['fields'], data['result']['values'])
+          RecordedResult.new(data[:result][:fields], data[:result][:values])
         else
           yield.tap do |result|
             result_data =
               if result && (result.respond_to?(:fields) || result.respond_to?(:columns))
                 fields = result.respond_to?(:fields) ? result.fields : result.columns
                 values = result.respond_to?(:values) ? result.values : result.to_a
-                { 'count' => result.count, 'fields' => fields, 'values' => values }
+                { count: result.count, fields: fields, values: values }
               end
             Recording.push(sql: sql, name: name, binds: type_casted_binds, result: result_data)
           end

data/lib/database_recorder/config.rb

@@ -8,6 +8,7 @@ module DatabaseRecorder
     include Singleton
 
     DEFAULT_DB_DRIVER = :active_record
+    DEFAULT_LOG_FORMAT = '[DB] %sql [%name]'
     DEFAULT_STORAGE = DatabaseRecorder::Storage::File
 
     DB_DRIVER_VALUES = %i[active_record mysql2 pg].freeze
@@ -17,18 +18,21 @@ module DatabaseRecorder
       redis: DatabaseRecorder::Storage::Redis
     }.freeze
 
-    attr_accessor :db_driver, :print_queries, :replay_recordings, :storage
+    attr_accessor :db_driver, :log_format, :print_queries, :replay_recordings, :storage, :storage_options
 
     class << self
       extend Forwardable
 
-      def_delegators :instance, :db_driver, :print_queries, :replay_recordings, :replay_recordings=, :storage
+      def_delegators :instance, :db_driver, :log_format, :log_format=, :print_queries, :replay_recordings,
+                     :replay_recordings=, :storage, :storage_options, :storage_options=
 
       def load_defaults
         instance.db_driver = DEFAULT_DB_DRIVER
+        instance.log_format = DEFAULT_LOG_FORMAT
         instance.print_queries = false
         instance.replay_recordings = false
         instance.storage = DEFAULT_STORAGE
+        instance.storage_options = {}
       end
 
       def db_driver=(value)

data/lib/database_recorder/core.rb

@@ -7,8 +7,11 @@ module DatabaseRecorder
     def log_query(sql, source = nil)
       log =
         case DatabaseRecorder::Config.print_queries
-        when true then "[DB] #{sql} [#{source}]"
-        when :color then "[DB] #{CodeRay.scan(sql, :sql).term} [#{source}]"
+        when true
+          DatabaseRecorder::Config.log_format.sub('%name', source.to_s).sub('%sql', sql)
+        when :color
+          code_ray_sql = CodeRay.scan(sql, :sql).term
+          DatabaseRecorder::Config.log_format.sub('%name', source.to_s).sub('%sql', code_ray_sql || '')
         end
 
       puts log if log
@@ -22,5 +25,29 @@ module DatabaseRecorder
       when :pg then PG::Recorder.setup
       end
     end
+
+    def string_keys_recursive(hash)
+      {}.tap do |h|
+        hash.each do |key, value|
+          h[key.to_s] = transform(value, :string_keys_recursive)
+        end
+      end
+    end
+
+    def symbolize_recursive(hash)
+      {}.tap do |h|
+        hash.each do |key, value|
+          h[key.to_sym] = transform(value, :symbolize_recursive)
+        end
+      end
+    end
+
+    def transform(value, source_method)
+      case value
+      when Hash then method(source_method).call(value)
+      when Array then value.map { |v| transform(v, source_method) }
+      else value
+      end
+    end
   end
 end

data/lib/database_recorder/mysql2/client_ext.rb

@@ -4,13 +4,13 @@ module DatabaseRecorder
   module Mysql2
     module ClientExt
       def query(sql, options = {})
-        Recorder.record(self, sql: sql) do
+        Recorder.store_query(self, sql: sql, source: :query) do
           super
         end
       end
 
       def prepare(*args)
-        Recorder.record(self, sql: args[0]) do
+        Recorder.prepare_statement(self, sql: args[0], source: :prepare) do
           super
         end
       end

data/lib/database_recorder/mysql2/recorded_result.rb

@@ -17,10 +17,10 @@ module DatabaseRecorder
       alias :size :count
 
       def prepare(data)
-        @count = data['count']
-        @fields = data['fields']
-        @entries = data['values']
-        # @values = data['values']
+        @count = data[:count]
+        @fields = data[:fields]
+        @entries = data[:values]
+        # @values = data[:values]
       end
 
       # def server_flags

data/lib/database_recorder/mysql2/recorder.rb

@@ -12,29 +12,16 @@ module DatabaseRecorder
           sql.match?(/information_schema.statistics/)
       end
 
-      def record(adapter, sql:)
-        return yield if ignore_query?(sql)
-
-        Core.log_query(sql)
-        if Config.replay_recordings && !Recording.cache.nil?
-          Recording.push(sql: sql)
-          data = Recording.cached_query_for(sql)
-          return yield unless data # cache miss
+      def format_result(result)
+        { count: result.count, fields: result.fields, values: result.to_a } if result.is_a?(::Mysql2::Result)
+        # else
+        #   last_insert_id = adapter.query('SELECT LAST_INSERT_ID() AS _dbr_last_insert_id').to_a
+        #   { 'count' => last_insert_id.count, 'fields' => ['id'], 'values' => last_insert_id }
+      end
 
-          RecordedResult.new.prepare(data['result'].slice('count', 'fields', 'values')) if data['result']
-        else
-          yield.tap do |result|
-            result_data =
-              if result.is_a? ::Mysql2::Result
-                { 'count' => result.count, 'fields' => result.fields, 'values' => result.to_a }
-                # else
-                #   last_insert_id = adapter.query('SELECT LAST_INSERT_ID() AS _dbr_last_insert_id').to_a
-                #   { 'count' => last_insert_id.count, 'fields' => ['id'], 'values' => last_insert_id }
-              end
-
-            Recording.push(sql: sql, result: result_data)
-          end
-        end
+      def prepare_statement(adapter, sql: nil, name: nil, binds: nil, source: nil)
+        @last_prepared = Recording.push_prepared(name: name, sql: sql, binds: binds, source: source)
+        yield if !Config.replay_recordings || Recording.cache.nil?
       end
 
       def setup
@@ -47,9 +34,38 @@ module DatabaseRecorder
         end
       end
 
-      def update_record(adapter, *args)
-        Recording.update_last(*args)
-        yield
+      def store_prepared_statement(adapter, source:, binds:)
+        # sql = @last_prepared&.send(:[], 'sql')
+        sql = @last_prepared[:sql]
+        Core.log_query(sql, source)
+        if Config.replay_recordings && !Recording.cache.nil?
+          data = Recording.cache.find { |query| query[:sql] == sql }
+          return yield unless data # cache miss
+
+          Recording.push(sql: data[:sql], binds: data[:binds], source: source)
+          RecordedResult.new(data[:result].slice(:count, :fields, :values))
+        else
+          yield.tap do |result|
+            Recording.update_prepared(sql: sql, binds: binds, result: format_result(result), source: source)
+          end
+        end
+      end
+
+      def store_query(adapter, sql:, source:)
+        return yield if ignore_query?(sql)
+
+        Core.log_query(sql, source)
+        if Config.replay_recordings && !Recording.cache.nil?
+          Recording.push(sql: sql, source: source)
+          data = Recording.cached_query_for(sql)
+          return yield unless data # cache miss
+
+          RecordedResult.new.prepare(data[:result].slice(:count, :fields, :values)) if data[:result]
+        else
+          yield.tap do |result|
+            Recording.push(sql: sql, result: format_result(result), source: source)
+          end
+        end
       end
     end
   end

data/lib/database_recorder/mysql2/statement_ext.rb

@@ -4,7 +4,7 @@ module DatabaseRecorder
   module Mysql2
     module StatementExt
       def execute(*args, **kwargs)
-        Recorder.update_record(self, *args) do
+        Recorder.store_prepared_statement(self, source: :execute, binds: args) do
           super
         end
       end

data/lib/database_recorder/pg/connection_ext.rb

@@ -4,47 +4,43 @@ module DatabaseRecorder
   module PG
     module ConnectionExt
       def async_exec(sql)
-        Recorder.record(sql: sql, source: :async_exec) do
+        Recorder.store_query(sql: sql, source: :async_exec) do
           super
         end
       end
 
       def sync_exec(sql)
-        Recorder.record(sql: sql, source: :sync_exec) do
+        Recorder.store_query(sql: sql, source: :sync_exec) do
           super
         end
       end
 
       def exec(*args)
-        Recorder.record(sql: args[0], source: :exec) do
+        Recorder.store_query(sql: args[0], source: :exec) do
           super
         end
       end
 
-      def query(*args)
-        Recorder.record(sql: args[0], source: :query) do
+      def exec_params(*args)
+        Recorder.store_query(sql: args[0], binds: args[1], source: :exec_params) do
           super
         end
       end
 
-      def exec_params(*args)
-        Recorder.record(sql: args[0], binds: args[1], source: :exec_params) do
+      def exec_prepared(*args)
+        Recorder.store_prepared_statement(name: args[0], binds: args[1], source: :exec_prepared) do
           super
         end
       end
 
-      # def async_exec_params(*args)
-      #   puts ">>> #{args[0]}"
-      #   super
-      # end
-
-      # def sync_exec_params(*args)
-      #   puts ">>> #{args[0]}"
-      #   super
-      # end
+      def prepare(*args)
+        Recorder.prepare_statement(name: args[0], sql: args[1], source: :prepare) do
+          super
+        end
+      end
 
-      def exec_prepared(*args)
-        Recorder.record(sql: args[0], binds: args[1], source: :exec_prepared) do
+      def query(*args)
+        Recorder.store_query(sql: args[0], source: :query) do
           super
         end
       end

data/lib/database_recorder/pg/recorded_result.rb

@@ -11,9 +11,9 @@ module DatabaseRecorder
       alias :rows :values
 
       def initialize(data)
-        @count = data['count']
-        @fields = data['fields']
-        @values = data['values']
+        @count = data[:count]
+        @fields = data[:fields]
+        @values = data[:values]
       end
 
       def clear; end

data/lib/database_recorder/pg/recorder.rb

@@ -11,29 +11,56 @@ module DatabaseRecorder
           sql.match?(/ pg_attribute |SHOW max_identifier_length|SHOW search_path/)
       end
 
-      def record(sql:, binds: nil, source: nil)
+      def format_result(result)
+        { count: result.count, fields: result.fields, values: result.values } if result
+      end
+
+      def prepare_statement(sql: nil, name: nil, binds: nil, source: nil)
+        Recording.push_prepared(name: name, sql: sql, binds: binds, source: source)
+        yield if !Config.replay_recordings || Recording.cache.nil?
+      end
+
+      def setup
+        ::PG::Connection.class_eval do
+          prepend ConnectionExt
+        end
+      end
+
+      def store_prepared_statement(name: nil, sql: nil, binds: nil, source: nil)
+        if Config.replay_recordings && !Recording.cache.nil?
+          data = Recording.cache.find { |query| query[:name] == name }
+          return yield unless data # cache miss
+
+          Core.log_query(data[:sql], source)
+          Recording.push(sql: data[:sql], binds: data[:binds], source: source)
+          RecordedResult.new(data[:result].slice(:count, :fields, :values))
+        else
+          Core.log_query(sql, source)
+          yield.tap do |query_result|
+            result = format_result(query_result)
+            query = Recording.update_prepared(name: name, sql: sql, binds: binds, result: result, source: source)
+            Core.log_query(query[:sql], source)
+          end
+        end
+      end
+
+      def store_query(name: nil, sql: nil, binds: nil, source: nil)
         return yield if ignore_query?(sql)
 
         Core.log_query(sql, source)
+        @prepared_statement = nil
         if Config.replay_recordings && !Recording.cache.nil?
-          Recording.push(sql: sql, binds: binds)
+          Recording.push(sql: sql, binds: binds, source: source)
           data = Recording.cached_query_for(sql)
           return yield unless data # cache miss
 
-          RecordedResult.new(data['result'].slice('count', 'fields', 'values'))
+          RecordedResult.new(data[:result].slice(:count, :fields, :values))
         else
           yield.tap do |result|
-            result_data = result ? { 'count' => result.count, 'fields' => result.fields, 'values' => result.values } : nil
-            Recording.push(sql: sql, binds: binds, result: result_data)
+            Recording.push(name: name, sql: sql, binds: binds, result: format_result(result), source: source)
           end
         end
       end
-
-      def setup
-        ::PG::Connection.class_eval do
-          prepend ConnectionExt
-        end
-      end
     end
   end
 end

data/lib/database_recorder/recording.rb

@@ -4,23 +4,25 @@ require 'forwardable'
 
 module DatabaseRecorder
   class Recording
-    attr_accessor :cache, :entities
-    attr_reader :from_cache, :options, :queries, :started
+    attr_accessor :cache, :entities, :metadata
+    attr_reader :from_cache, :options, :prepared_queries, :queries, :started
 
     def initialize(options: {})
       (@@instances ||= {})[Process.pid] = self
       @cache = nil
       @entities = []
+      @metadata = {}
       @options = options
       @queries = []
       @search_index = 0
+      @@prepared_queries ||= {}
     end
 
     def cached_query_for(sql)
       current = @search_index
       match = cache[@search_index..].find do |item|
         current += 1
-        item['sql'] == sql
+        item[:sql] == sql
       end
       return unless match
 
@@ -31,39 +33,49 @@ module DatabaseRecorder
     end
 
     def new_entity(model:, id:)
-      @entities.push('model' => model, 'id' => id)
+      @entities.push(model: model, id: id)
     end
 
     def pull_entity
       @entities.shift
     end
 
-    def push(sql:, binds: nil, result: nil, name: nil)
-      query = { 'name' => name, 'sql' => sql, 'binds' => binds, 'result' => result }.compact
+    def push(sql:, name: nil, binds: nil, result: nil, source: nil)
+      query = { name: name, sql: sql, binds: binds, result: result }.compact
       @queries.push(query)
     end
 
+    def push_prepared(name: nil, sql: nil, binds: nil, result: nil, source: nil)
+      query = { name: name, sql: sql, binds: binds, result: result }.compact
+      @@prepared_queries[name || sql] = query
+    end
+
     def start
       @started = true
-      storage = Config.storage&.new(self, name: options[:name])
+      storage = Config.storage&.new(self, name: options[:name], options: Config.storage_options)
       @from_cache = storage&.load
       yield
       storage&.save unless from_cache
       @started = false
-      result = { current_queries: queries.map { _1['sql'] } }
-      result[:stored_queries] = cache.map { _1['sql'] } if from_cache
+      result = { current_queries: queries.map { |query| query[:sql] } }
+      result[:stored_queries] = cache.map { |query| query[:sql] } if from_cache
       result
     end
 
-    def update_last(*args)
-      @queries.last['binds'] = args
+    def update_prepared(name: nil, sql: nil, binds: nil, result: nil, source: nil)
+      query = @@prepared_queries[name || sql]
+      query[:sql] = sql if sql
+      query[:binds] = binds if binds
+      query[:result] = result if result
+      @queries.push(query)
+      query
     end
 
     class << self
       extend Forwardable
 
-      def_delegators :current_instance, :cache, :cached_query_for, :from_cache, :new_entity, :pull_entity, :push,
-                     :queries, :update_last
+      def_delegators :current_instance, :cache, :cached_query_for, :from_cache, :new_entity, :prepared_queries,
+                     :pull_entity, :push, :push_prepared, :queries, :update_prepared
 
       def current_instance
         (@@instances ||= {})[Process.pid]

data/lib/database_recorder/rspec.rb

@@ -13,9 +13,10 @@ module DatabaseRecorder
         config.around(:each, :dbr) do |example|
           ref = (example.metadata[:scoped_id] || '').split(':')[-1]
           options = {}
+          options[:name] = "#{example.full_description}__#{ref}"
           options.merge!(example.metadata[:dbr]) if example.metadata[:dbr].is_a?(Hash)
-          options.merge!(example: example, name: "#{example.full_description}__#{ref}")
           Recording.new(options: options).tap do |recording|
+            recording.metadata = { example: example.id, started_at: Time.now }
             result = recording.start { example.run }
             if options[:verify_queries] && result[:stored_queries]
               expect(result[:stored_queries]).to match_array(result[:current_queries])

data/lib/database_recorder/storage/base.rb

@@ -3,9 +3,10 @@
 module DatabaseRecorder
   module Storage
     class Base
-      def initialize(recording, name:)
+      def initialize(recording, name:, options: {})
         @recording = recording
         @name = name
+        @options = options
       end
     end
   end

data/lib/database_recorder/storage/file.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+require 'yaml'
+
 module DatabaseRecorder
   module Storage
     class File < Base
       def load
-        stored_data = ::File.exist?(record_file) ? ::File.read(record_file) : false
+        stored_data = ::File.exist?(storage_path) ? ::File.read(storage_path) : false
         if stored_data
-          data = YAML.load(stored_data) # rubocop:disable Security/YAMLLoad
-          @recording.cache = data['queries']
-          @recording.entities = data['entities']
+          parsed_data = YAML.load(stored_data) # rubocop:disable Security/YAMLLoad
+          data = Core.symbolize_recursive(parsed_data)
+          @recording.cache = data[:queries] || []
+          @recording.entities = data[:entities]
           true
         else
           false
@@ -16,10 +20,22 @@ module DatabaseRecorder
       end
 
       def save
-        data = { 'queries' => @recording.queries }
-        data['entities'] = @recording.entities if @recording.entities.any?
-        serialized_data = data.to_yaml
-        ::File.write(record_file, serialized_data)
+        data = {}
+        data[:metadata] = @recording.metadata unless @recording.metadata.empty?
+        data[:queries] = @recording.queries if @recording.queries.any?
+        data[:entities] = @recording.entities if @recording.entities.any?
+        serialized_data = ::YAML.dump(Core.string_keys_recursive(data))
+        ::File.write(storage_path, serialized_data)
+        true
+      end
+
+      def storage_path
+        @storage_path ||= begin
+          name = normalize_name(@name)
+          path = @options[:recordings_path] || 'spec/dbr'
+          ::FileUtils.mkdir_p(path)
+          "#{path}/#{name}.yml"
+        end
       end
 
       private
@@ -27,13 +43,6 @@ module DatabaseRecorder
       def normalize_name(string)
         string.gsub(%r{[:/]}, '-').gsub(/[^\w-]/, '_')
       end
-
-      def record_file
-        name = normalize_name(@name)
-        path = 'spec/dbr'
-        FileUtils.mkdir_p(path)
-        "#{path}/#{name}.yml"
-      end
     end
   end
 end

data/lib/database_recorder/storage/redis.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module DatabaseRecorder
   module Storage
     class Redis < Base
+      def connection
+        @connection ||= @options[:connection] || ::Redis.new
+      end
+
       def load
-        stored_data = self.class.connection.get(@name)
+        stored_data = connection.get(@name)
         if stored_data
-          data = JSON.parse(stored_data)
-          @recording.cache = data['queries']
-          @recording.entities = data['entities']
+          parsed_data = JSON.parse(stored_data)
+          data = Core.symbolize_recursive(parsed_data)
+          @recording.cache = data[:queries] || []
+          @recording.entities = data[:entities]
           true
         else
           false
@@ -16,16 +23,13 @@ module DatabaseRecorder
       end
 
       def save
-        data = { 'queries' => @recording.queries }
-        data['entities'] = @recording.entities if @recording.entities.any?
+        data = {}
+        data[:metadata] = @recording.metadata unless @recording.metadata.empty?
+        data[:queries] = @recording.queries if @recording.queries.any?
+        data[:entities] = @recording.entities if @recording.entities.any?
         serialized_data = data.to_json
-        self.class.connection.set(@name, serialized_data)
-      end
-
-      class << self
-        def connection
-          @connection ||= ::Redis.new
-        end
+        connection.set(@name, serialized_data)
+        true
       end
     end
   end

data/lib/database_recorder/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :nocov:
 module DatabaseRecorder
-  VERSION = '0.1.1'
+  VERSION = '0.2.2'
 end
+# :nocov:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_recorder
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderay