detector 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78362ec4d3b8705fcb95855b07747ac13ad8dc03942743ace4ab9699659c7b6e
+  data.tar.gz: 5efa218d244399e55a5d31aa8480c96b1434509fe0fe2b8bf690812b5279c7aa
+SHA512:
+  metadata.gz: 2b3b958c50d44739c8f7825ec4d0b1db7383e866cd62f05ffc2957b5afa8886ca5bc50e329949c097155429c37175e66fb1b7a182ef6606a5925fdd30bc15517
+  data.tar.gz: 2f26cec088bc720b9b6644a0bd6bb01f0ed07676887170481ec6a8d7c94d7096a35f0c136a6e4677fb103456aa4938265e51ae41107ed8e74cd0e5efbdc5b73c

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jonathan Siegel
+
+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,75 @@
+# Detector
+
+A Ruby gem for detecting and analyzing various database systems. Detector is a system manager's toolkit that helps you quickly check database stats and structure.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'detector'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install detector
+```
+
+## Usage
+
+### CLI
+
+```
+$ detector "postgres://user:pass@host:port/dbname"
+```
+
+This will display:
+- Database system type
+- Version
+- Database count
+- For the 3 largest databases:
+  - Table count
+  - The 3 largest tables with row counts
+
+### Ruby API
+
+```ruby
+require 'detector'
+
+# Create a detector for a database
+db = Detector.detect("postgres://user:pass@host:port/dbname")
+
+# Get basic info
+db.kind          # => :postgres
+db.host          # => "host"
+db.port          # => 5432
+db.version       # => "PostgreSQL 12.1 on x86_64-pc-linux-gnu, ..."
+
+# Get database stats
+db.database_count  # => 5
+db.databases       # => [{ name: "db1", size: "1.2 GB", ... }, ...]
+
+# Get table stats (requires database name)
+db_name = db.databases.first[:name]  # Or any database you want to inspect
+db.table_count(db_name)   # => 42 
+db.tables(db_name)        # => [{ name: "users", row_count: 10000, size: "500 MB", ... }, ...]
+```
+
+## Supported Systems
+
+- PostgreSQL
+- MySQL
+- MariaDB
+- Redis
+- SMTP
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/detector

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "detector"
+
+if ARGV.empty?
+  puts "Usage: detector <URI>"
+  puts "Example: detector \"postgres://user:pass@host:port/dbname\""
+  exit 1
+end
+
+uri = ARGV[0]
+detector = Detector.detect(uri)
+
+if detector.nil?
+  puts "Invalid or unsupported URI: #{uri}"
+  exit 1
+end
+
+puts "Detected: #{detector.kind}"
+puts "Version: #{detector.version}"
+puts "Host: #{detector.host}:#{detector.port}"
+
+if detector.databases?
+  db_count = detector.database_count
+  puts "\nDatabases: #{db_count}"
+  
+  if db_count && db_count > 0
+    dbs = detector.databases.first(3)
+    dbs.each do |db|
+      db_name = db[:name]
+      puts "\nDatabase: #{db_name} (#{db[:size]})"
+      
+      if detector.tables?
+        tables = detector.tables(db_name).first(3) 
+        puts "  Tables: #{detector.table_count(db_name)}"
+        
+        tables.each do |table|
+          puts "    - #{table[:name]}: #{table[:row_count]} rows (#{table[:size]})"
+        end
+      end
+    end
+  end
+end 

data/lib/detector/addons/mariadb.rb

@@ -0,0 +1,88 @@
+require_relative 'mysql'
+
+module Detector
+  module Addons
+    class MariaDB < MySQL
+      def self.handles_uri?(uri)
+        uri.scheme.downcase == 'mariadb'
+      end
+      
+      def self.capabilities_for(url)
+        { sql: true, kv: true, url: url, kind: :mariadb, databases: true, tables: true }
+      end
+    
+      def version
+        return nil unless info
+        "MariaDB #{info['version']} on #{info['database']} (#{info['user']})"
+      end
+      
+      def databases
+        return [] unless connection
+        begin
+          # First get all databases
+          db_list = connection.query("SELECT schema_name AS name 
+                                     FROM information_schema.SCHEMATA 
+                                     WHERE schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')").map do |row|
+            row['name']
+          end
+          
+          # For each database, get its size
+          result = []
+          db_list.each do |db_name|
+            size_query = "SELECT 
+                            IFNULL(FORMAT(SUM(data_length + index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
+                            IFNULL(SUM(data_length + index_length), 0) AS raw_size
+                          FROM information_schema.TABLES 
+                          WHERE table_schema = '#{db_name}'"
+            
+            size_data = connection.query(size_query).first
+            result << { 
+              name: db_name, 
+              size: "#{size_data['size_mb']} MB", 
+              raw_size: size_data['raw_size'].to_i 
+            }
+          end
+          
+          # Sort by size
+          @databases = result.sort_by { |db| -db[:raw_size] }
+        rescue => e
+          puts "Error getting databases: #{e.message}"
+          []
+        end
+      end
+      
+      def tables(database_name)
+        return [] unless connection
+        
+        begin
+          @tables ||= {}
+          @tables[database_name] ||= connection.query("SELECT 
+                                                 table_name AS name, 
+                                                 IFNULL(FORMAT((data_length + index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
+                                                 IFNULL((data_length + index_length), 0) AS raw_size,
+                                                 IFNULL(table_rows, 0) AS row_count
+                                                 FROM information_schema.TABLES 
+                                                 WHERE table_schema = '#{database_name}'
+                                                 ORDER BY raw_size DESC").map do |row|
+            { 
+              name: row['name'], 
+              size: "#{row['size_mb']} MB", 
+              raw_size: row['raw_size'].to_i, 
+              row_count: row['row_count'].to_i 
+            }
+          end
+        rescue => e
+          puts "Error getting tables for #{database_name}: #{e.message}"
+          []
+        end
+      end
+      
+      def cli_name
+        "mariadb"
+      end
+    end
+  end
+  
+  # Register the addon
+  Base.register_addon(:mariadb, Addons::MariaDB)
+end 

data/lib/detector/addons/mysql.rb

@@ -0,0 +1,97 @@
+require 'mysql2'
+
+module Detector
+  module Addons
+    class MySQL < Base
+      def self.handles_uri?(uri)
+        uri.scheme.downcase == 'mysql'
+      end
+      
+      def self.capabilities_for(url)
+        { sql: true, kv: true, url: url, kind: :mysql, databases: true, tables: true }
+      end
+    
+      def connection
+        @conn ||= Mysql2::Client.new(
+          host: host,
+          username: uri.user,
+          password: uri.password,
+          database: uri.path[1..-1],
+          port: port
+        ) rescue nil
+      end
+      
+      def info
+        return nil unless connection
+        @info ||= connection.query("SELECT VERSION() AS version, DATABASE() AS `database`, USER() AS user").first
+      end
+      
+      def version
+        return nil unless info
+        "MySQL #{info['version']} on #{info['database']} (#{info['user']})"
+      end
+      
+      def usage
+        return nil unless connection && info
+        result = connection.query("SELECT ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS size FROM information_schema.TABLES WHERE table_schema = '#{info['database']}'").first
+        "#{result['size']} MB"
+      end
+      
+      def database_count
+        return nil unless connection
+        @database_count ||= connection.query("SELECT COUNT(*) AS count FROM information_schema.SCHEMATA WHERE schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')").first['count']
+      end
+      
+      def databases
+        return [] unless connection
+        @databases ||= connection.query("SELECT schema_name AS name,
+                                      FORMAT(SUM(data_length + index_length) / 1024 / 1024, 2) AS size_mb,
+                                      SUM(data_length + index_length) AS raw_size
+                                      FROM information_schema.SCHEMATA
+                                      JOIN information_schema.TABLES ON table_schema = schema_name
+                                      WHERE schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
+                                      GROUP BY schema_name
+                                      ORDER BY raw_size DESC").map do |row|
+          { name: row['name'], size: "#{row['size_mb']} MB", raw_size: row['raw_size'].to_i }
+        end
+      end
+      
+      def table_count(database_name)
+        return nil unless connection
+        connection.query("SELECT COUNT(*) AS count FROM information_schema.TABLES WHERE table_schema = '#{database_name}'").first['count']
+      end
+      
+      def tables(database_name)
+        return [] unless connection
+        
+        @tables ||= {}
+        @tables[database_name] ||= connection.query("SELECT table_name AS name, 
+                                                   FORMAT((data_length + index_length) / 1024 / 1024, 2) AS size_mb,
+                                                   (data_length + index_length) AS raw_size,
+                                                   table_rows AS row_count
+                                                   FROM information_schema.TABLES 
+                                                   WHERE table_schema = '#{database_name}'
+                                                   ORDER BY raw_size DESC").map do |row|
+          { name: row['name'], size: "#{row['size_mb']} MB", raw_size: row['raw_size'].to_i, row_count: row['row_count'].to_i }
+        end
+      end
+      
+      def connection_count
+        return nil unless connection
+        connection.query("SELECT COUNT(*) AS count FROM information_schema.PROCESSLIST").first['count']
+      end
+      
+      def connection_limit
+        return nil unless connection
+        connection.query("SHOW VARIABLES LIKE 'max_connections'").first['Value'].to_i
+      end
+      
+      def cli_name
+        "mysql"
+      end
+    end
+  end
+  
+  # Register the addon
+  Base.register_addon(:mysql, Addons::MySQL)
+end 

data/lib/detector/addons/postgres.rb

@@ -0,0 +1,122 @@
+require 'pg'
+
+module Detector
+  module Addons
+    class Postgres < Base
+      def self.handles_uri?(uri)
+        uri.scheme.downcase =~ /postgres/
+      end
+      
+      def self.capabilities_for(url)
+        { sql: true, kv: true, url: url, kind: :postgres, databases: true, tables: true }
+      end
+    
+      def connection
+        @conn ||= PG::Connection.new(uri) rescue nil
+      end
+      
+      def version
+        return nil unless connection
+        @version ||= connection.exec("SELECT version()").first['version']
+      end
+      
+      def usage
+        return nil unless connection
+        connection.exec("SELECT pg_size_pretty(pg_database_size(current_database())) AS size").first['size']
+      end
+      
+      def table_count(database_name)
+        return nil unless connection
+        
+        # If we need to query a different database, temporarily connect to it
+        if database_name != current_database
+          # Create a temporary connection to the specified database
+          temp_conn = PG::Connection.new(host: host, port: port, user: uri.user, 
+                                         password: uri.password, dbname: database_name) rescue nil
+          return nil unless temp_conn
+          
+          count = temp_conn.exec("SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'").first['count'].to_i
+          temp_conn.close
+          return count
+        end
+        
+        # Query the current database
+        @table_count ||= connection.exec("SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'").first['count'].to_i
+      end
+      
+      def current_database
+        @current_db ||= connection.exec("SELECT current_database()").first['current_database']
+      end
+      
+      def tables(database_name)
+        return [] unless connection
+        
+        # If we need to query a different database, temporarily connect to it
+        if database_name != current_database
+          # Create a temporary connection to the specified database
+          temp_conn = PG::Connection.new(host: host, port: port, user: uri.user, 
+                                         password: uri.password, dbname: database_name) rescue nil
+          return [] unless temp_conn
+          
+          result = temp_conn.exec("SELECT table_name, 
+                                pg_size_pretty(pg_total_relation_size(quote_ident(table_name))) as size,
+                                pg_total_relation_size(quote_ident(table_name)) as raw_size,
+                                (SELECT reltuples::bigint FROM pg_class WHERE relname = table_name) as row_count
+                                FROM information_schema.tables 
+                                WHERE table_schema = 'public'
+                                ORDER BY raw_size DESC").map do |row|
+            { name: row['table_name'], size: row['size'], raw_size: row['raw_size'].to_i, row_count: row['row_count'].to_i }
+          end
+          
+          temp_conn.close
+          return result
+        end
+        
+        # Query the current database
+        @tables ||= {}
+        @tables[database_name] ||= connection.exec("SELECT table_name, 
+                                                 pg_size_pretty(pg_total_relation_size(quote_ident(table_name))) as size,
+                                                 pg_total_relation_size(quote_ident(table_name)) as raw_size,
+                                                 (SELECT reltuples::bigint FROM pg_class WHERE relname = table_name) as row_count
+                                                 FROM information_schema.tables 
+                                                 WHERE table_schema = 'public'
+                                                 ORDER BY raw_size DESC").map do |row|
+          { name: row['table_name'], size: row['size'], raw_size: row['raw_size'].to_i, row_count: row['row_count'].to_i }
+        end
+      end
+      
+      def database_count
+        return nil unless connection
+        @database_count ||= connection.exec("SELECT count(*) FROM pg_database WHERE datistemplate = false").first['count'].to_i
+      end
+      
+      def databases
+        return [] unless connection
+        @databases ||= connection.exec("SELECT datname, pg_size_pretty(pg_database_size(datname)) as size, 
+                                      pg_database_size(datname) as raw_size 
+                                      FROM pg_database 
+                                      WHERE datistemplate = false 
+                                      ORDER BY raw_size DESC").map do |row|
+          { name: row['datname'], size: row['size'], raw_size: row['raw_size'].to_i }
+        end
+      end
+      
+      def connection_count
+        return nil unless connection
+        connection.exec("SELECT count(*) FROM pg_stat_activity").first['count'].to_i
+      end
+      
+      def connection_limit
+        return nil unless connection
+        connection.exec("SELECT current_setting('max_connections')").first['current_setting'].to_i
+      end
+      
+      def cli_name
+        "psql"
+      end
+    end
+  end
+  
+  # Register the addon
+  Base.register_addon(:postgres, Addons::Postgres)
+end 

data/lib/detector/addons/redis.rb

@@ -0,0 +1,79 @@
+require 'redis'
+
+module Detector
+  module Addons
+    class Redis < Base
+      def self.handles_uri?(uri)
+        uri.scheme.downcase == 'redis' || uri.scheme.downcase == 'rediss'
+      end
+      
+      def self.capabilities_for(url)
+        { kv: true, sql: false, url: url, kind: :redis, databases: true, tables: false }
+      end
+    
+      def connection
+        return @conn if @conn
+        
+        if uri.scheme == 'rediss'
+          @conn = ::Redis.new(url: @url, port: uri.port, timeout: 5.0, ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }) rescue nil
+        else
+          @conn = ::Redis.new(url: @url, timeout: 5.0) rescue nil
+        end
+      end
+      
+      def info
+        return nil unless connection
+        @info ||= connection.info
+      end
+      
+      def version
+        return nil unless info
+        "Redis #{info['redis_version']} on #{info['os']} #{info['arch']}, compiled by #{info['gcc_version']}, #{info['arch_bits']}-bit"
+      end
+      
+      def usage
+        return nil unless info
+        
+        per = (info['used_memory'].to_f / info['maxmemory'].to_f) * 100
+        percent = sprintf("%.2f%%", per)
+        "#{info['used_memory_human']} of #{info['maxmemory_human']} used (#{percent})" rescue -1
+      end
+      
+      def database_count
+        return nil unless connection
+        connection.info['keyspace'].keys.size
+      end
+      
+      def databases
+        return [] unless info && info['keyspace']
+        
+        info['keyspace'].map do |db_name, stats|
+          keys, expires = stats.split(',').map { |s| s.split('=').last.to_i }
+          { name: db_name, keys: keys, expires: expires, stats: stats }
+        end.sort_by { |db| -db[:keys] }
+      end
+      
+      def table_count
+        return nil unless connection
+        connection.dbsize rescue 0
+      end
+      
+      def connection_count
+        return nil unless info
+        info['connected_clients'].to_i rescue 0
+      end
+      
+      def connection_limit
+        return nil unless info
+        info['maxclients'].to_i rescue 0
+      end
+      
+      def cli_name
+        "redis-cli"
+      end
+    end
+  end
+  
+  # Register the addon
+  Base.register_addon(:redis, Addons::Redis)
+end 

data/lib/detector/addons/smtp.rb

@@ -0,0 +1,40 @@
+require 'net/smtp'
+
+module Detector
+  module Addons
+    class SMTP < Base
+      def self.handles_uri?(uri)
+        uri.scheme.downcase == 'smtp' || uri.scheme.downcase == 'smtps'
+      end
+      
+      def self.capabilities_for(url)
+        { kv: true, sql: false, url: url, kind: :smtp, databases: false, tables: false }
+      end
+    
+      def connection
+        return @conn if @conn
+        
+        begin
+          @conn = Net::SMTP.new(host, port)
+          @conn.open_timeout = 5
+          @conn.start('detector.local', uri.user, uri.password, :login)
+          @conn
+        rescue => e
+          nil
+        end
+      end
+      
+      def version
+        return nil unless connection
+        "SMTP server at #{host}:#{port}"
+      end
+      
+      def cli_name
+        "telnet"
+      end
+    end
+  end
+  
+  # Register the addon
+  Base.register_addon(:smtp, Addons::SMTP)
+end 

data/lib/detector/base.rb

@@ -0,0 +1,142 @@
+require 'socket'
+
+module Detector
+  class Base
+    @@addons = {}
+    
+    def self.register_addon(kind, klass)
+      @@addons[kind] = klass
+    end
+    
+    def self.detect(val)
+      return nil unless val =~ /\A#{URI::regexp}\z/
+      
+      begin
+        uri = URI.parse(val)
+      rescue => e
+        puts "Error parsing URI: #{e.class} #{e.message}"
+        return nil
+      end
+      
+      # Try each registered addon to see if it can handle this URI
+      @@addons.each do |kind, klass|
+        if klass.handles_uri?(uri)
+          detector = klass.new(val)
+          return detector if detector.valid?
+        end
+      end
+      
+      # Fallback to generic handling if no addon matched
+      nil
+    end
+    
+    # Default implementation to be overridden by subclasses
+    def self.handles_uri?(uri)
+      false
+    end
+    
+    # Default implementation to get capabilities, should be overridden by subclasses
+    def self.capabilities_for(url)
+      nil
+    end
+
+    def initialize(url)
+      @url = url
+      @capabilities = self.class.capabilities_for(url)
+      @keys = []
+    end
+    
+    attr_accessor :uri, :keys
+    
+    def sql?
+      valid? && @capabilities[:sql]
+    end
+    
+    def valid?
+      @capabilities && @capabilities[:kind]
+    end
+    
+    def kind
+      @capabilities && @capabilities[:kind]
+    end
+    
+    def databases?
+      @capabilities && @capabilities[:databases]
+    end
+    
+    def tables?
+      @capabilities && @capabilities[:tables]
+    end
+    
+    def summary
+      return "Invalid URI" unless valid?
+      "#{kind} in #{host}"
+    end
+    
+    def uri
+      @uri ||= URI.parse(@url)
+    end
+    
+    def host
+      return nil unless valid?
+      uri.host
+    end
+    
+    def port
+      return nil unless valid?
+      uri.port
+    end
+    
+    def ip
+      return nil unless valid?
+      Resolv.getaddress(host)
+    rescue
+      nil
+    end
+    
+    def connection?
+      connection.present?
+    end
+    
+    def connection
+      nil
+    end
+    
+    def ping
+      return nil unless valid?
+      tcp_test
+    end
+    
+    def tcp_test
+      TCPSocket.new(ip, port).present? rescue nil
+    end
+    
+    def table_count
+      nil
+    end
+    
+    def database_count
+      nil
+    end
+    
+    def databases
+      []
+    end
+    
+    def tables(database_name)
+      []
+    end
+    
+    def cli_name
+      nil
+    end
+    
+    def version
+      nil
+    end
+    
+    def usage
+      nil
+    end
+  end
+end 

data/lib/detector/version.rb

@@ -0,0 +1,3 @@
+module Detector
+  VERSION = "0.1.0"
+end 

data/lib/detector.rb

@@ -0,0 +1,17 @@
+require 'uri'
+require 'resolv'
+require 'detector/version'
+require 'detector/base'
+require 'detector/addons/postgres'
+require 'detector/addons/redis'
+require 'detector/addons/mysql'
+require 'detector/addons/mariadb'
+require 'detector/addons/smtp'
+
+module Detector
+  class Error < StandardError; end
+
+  def self.detect(uri_string)
+    Base.detect(uri_string)
+  end
+end 

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: detector
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Siegel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: resolv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: net-smtp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: A system manager's toolkit to detect and analyze various database systems
+  like Postgres, MySQL, Redis, etc.
+email:
+- "<248302+usiegj00@users.noreply.github.com>"
+executables:
+- detector
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/detector
+- lib/detector.rb
+- lib/detector/addons/mariadb.rb
+- lib/detector/addons/mysql.rb
+- lib/detector/addons/postgres.rb
+- lib/detector/addons/redis.rb
+- lib/detector/addons/smtp.rb
+- lib/detector/base.rb
+- lib/detector/version.rb
+homepage: https://github.com/usiegj00/detector
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/usiegj00/detector
+  source_code_uri: https://github.com/usiegj00/detector
+  changelog_uri: https://github.com/usiegj00/detector/blob/main/CHANGELOG.md
+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.5.16
+signing_key:
+specification_version: 4
+summary: Detect and analyze various database systems
+test_files: []