detector 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78c814535b333de1c5e5688053248859109551711abf79dec4fb4c3aca723b5c
-  data.tar.gz: 6589e309685233203306e23f8aa581470d2af49624f8adfd8643d063670e6cb2
+  metadata.gz: ab9800bbb6b9322ca7e8115b438c89cf5da96febc891e1ae6cf55ff8de6ff011
+  data.tar.gz: 4916567db9f219e16d9fe3bef938dbc51958d786205894a850074686c5e41400
 SHA512:
-  metadata.gz: ac198d4ecc2dd09814e8bebbed2e0c5e165cd8f722bb374d3e5ba76ba61361036f7bcf071bffd26dac5ecb8a4ba4dfdca8fb29f92439ad8ea827b2ec82908344
-  data.tar.gz: 5d3220c7780b78167c16fd43c1e3f663026f7ab4b471606b1b2db784eee741f9606bfe380180efca85d961cfab780f2a3f9deca273658a6b4e07d3e5d78e0acd
+  metadata.gz: aad9b58db57085e77b3543c50297d57d779506b93e0f89fd7475df0de19c3b45170127588dc7754fae9f5e256feb1939cb5aba88c98bc56d6289f9413f866ad6
+  data.tar.gz: 3dc3ef92bfe6bb083f90e282d15ab0866722da1dfaddb30b8cae8076150755fad0c31274649eef7e16a19b993fb07443d68d301eb236ffaa5c7beaf91c234216

data/README.md

@@ -52,6 +52,14 @@ db.host          # => "host"
 db.port          # => 5432
 db.version       # => "PostgreSQL 12.1 on x86_64-pc-linux-gnu, ..."
 
+# Detect infrastructure
+db.infrastructure # => "Amazon Web Services", "Google Cloud Platform", etc.
+
+# Geographic information
+db.geography     # => "Ashburn, Virginia, United States"
+db.region        # => "us-east-1"
+db.asn           # => "AS16509"
+
 # Get database stats
 db.database_count  # => 5
 db.databases       # => [{ name: "db1", size: "1.2 GB", ... }, ...]

data/bin/detector

@@ -4,6 +4,7 @@ require "bundler/setup"
 require "detector"
 
 if ARGV.empty?
+  puts "Detector v#{Detector::VERSION}"
   puts "Usage: detector <URI>"
   puts "Example: detector \"postgres://user:pass@host:port/dbname\""
   exit 1
@@ -17,10 +18,31 @@ if detector.nil?
   exit 1
 end
 
+puts "Detector v#{Detector::VERSION}"
 puts "Detected: #{detector.kind}"
 puts "Version: #{detector.version}"
 puts "Host: #{detector.host}:#{detector.port}"
 
+if detector.user_access_level
+  puts "User access level: #{detector.user_access_level}"
+end
+
+if detector.infrastructure
+  puts "Infrastructure: #{detector.infrastructure}"
+end
+
+if detector.geography
+  puts "Location: #{detector.geography}"
+end
+
+if detector.region
+  puts "Region: #{detector.region}"
+end
+
+if detector.asn
+  puts "ASN: #{detector.asn}"
+end
+
 if detector.databases?
   db_count = detector.database_count
   puts "\nDatabases: #{db_count}"

data/lib/detector/addons/mariadb.rb

@@ -80,6 +80,32 @@ module Detector
       def cli_name
         "mariadb"
       end
+      
+      def user_access_level
+        # Start with MySQL access level check
+        access_level = super
+        
+        # Add MariaDB-specific details if needed
+        return access_level unless connection
+        
+        # Check for MariaDB-specific roles (MariaDB 10.0.5+)
+        begin
+          result = connection.query("SELECT 1 FROM information_schema.plugins WHERE plugin_name = 'ROLES'")
+          if result.count > 0
+            roles_result = connection.query("SELECT CURRENT_ROLE()").first
+            current_role = roles_result.values.first
+            
+            # If a role is active, append it to the access level
+            if current_role && current_role != '' && current_role != 'NONE'
+              return "#{access_level} (Role: #{current_role})"
+            end
+          end
+        rescue => e
+          # Role system not available or not accessible to user
+        end
+        
+        access_level
+      end
     end
   end
   

data/lib/detector/addons/mysql.rb

@@ -89,6 +89,67 @@ module Detector
       def cli_name
         "mysql"
       end
+      
+      def user_access_level
+        return nil unless connection
+        
+        # Get all privileges for current user
+        grants = []
+        begin
+          result = connection.query("SHOW GRANTS FOR CURRENT_USER()")
+          result.each do |row|
+            grants << row.values.first
+          end
+        rescue => e
+          return "Limited access (unable to check privileges)"
+        end
+        
+        grant_text = grants.join(" ")
+        
+        # Check for root/admin privileges
+        if grant_text =~ /ALL PRIVILEGES ON \*\.\* TO/i
+          return "Administrator (all privileges)"
+        end
+        
+        # Check for global privileges
+        if grant_text =~ /GRANT .* ON \*\.\*/i
+          global_privs = []
+          global_privs << "CREATE USER" if grant_text =~ /CREATE USER/i
+          global_privs << "PROCESS" if grant_text =~ /PROCESS/i
+          global_privs << "SUPER" if grant_text =~ /SUPER/i
+          global_privs << "RELOAD" if grant_text =~ /RELOAD/i
+          global_privs << "SHUTDOWN" if grant_text =~ /SHUTDOWN/i
+          
+          if global_privs.include?("CREATE USER") || global_privs.include?("SUPER")
+            return "Power user (#{global_privs.join(", ")})"
+          elsif !global_privs.empty?
+            return "System monitor (#{global_privs.join(", ")})"
+          end
+        end
+        
+        # Check for database-level privileges
+        db_with_all = []
+        if grant_text =~ /ALL PRIVILEGES ON (`[^`]+`|\w+)\./i
+          db_name = $1.gsub(/`/, "")
+          db_with_all << db_name
+        end
+        
+        if !db_with_all.empty?
+          return "Database admin (full access to: #{db_with_all.join(", ")})"
+        end
+        
+        # Check for specific privileges
+        can_write = grant_text =~ /INSERT|UPDATE|DELETE|CREATE|ALTER|DROP/i
+        can_read = grant_text =~ /SELECT/i
+        
+        if can_write
+          "Write access"
+        elsif can_read
+          "Read-only access"
+        else
+          "Limited access"
+        end
+      end
     end
   end
   

data/lib/detector/addons/postgres.rb

@@ -114,6 +114,46 @@ module Detector
       def cli_name
         "psql"
       end
+      
+      def user_access_level
+        return nil unless connection
+        
+        is_superuser = connection.exec("SELECT usesuper FROM pg_user WHERE usename = current_user").first["usesuper"] == "t" rescue false
+        is_replication = connection.exec("SELECT rolreplication FROM pg_roles WHERE rolname = current_user").first["rolreplication"] == "t" rescue false
+        roles = connection.exec("SELECT r.rolname FROM pg_roles r JOIN pg_auth_members m ON r.oid = m.roleid JOIN pg_roles u ON m.member = u.oid WHERE u.rolname = current_user").map { |row| row["rolname"] } rescue []
+        
+        create_db = connection.exec("SELECT usecreatedb FROM pg_user WHERE usename = current_user").first["usecreatedb"] == "t" rescue false
+        
+        if is_superuser
+          "Superuser (full access)"
+        elsif is_replication
+          "Replication user (system-level replication access)"
+        elsif create_db
+          "Database creator (can create new databases)"
+        elsif roles.include?("rds_superuser")
+          "RDS Superuser (limited admin privileges)"
+        else
+          # Check if can access system catalogs (higher than regular user)
+          begin
+            connection.exec("SELECT count(*) FROM pg_shadow")
+            "Power user (access to system catalogs)"
+          rescue => e
+            # Check if can create tables in current database
+            begin
+              connection.exec("CREATE TABLE __temp_access_check (id int); DROP TABLE __temp_access_check;")
+              "Regular user (table management)"
+            rescue => e
+              # Check for readonly access
+              begin
+                connection.exec("SELECT current_database()")
+                "Read-only user"
+              rescue => e
+                "Limited access"
+              end
+            end
+          end
+        end
+      end
     end
   end
   

data/lib/detector/addons/redis.rb

@@ -71,6 +71,82 @@ module Detector
       def cli_name
         "redis-cli"
       end
+      
+      def user_access_level
+        return nil unless connection
+        
+        # Redis 6.0+ supports ACLs, older versions just have auth or no auth
+        redis_version = info['redis_version'].to_s
+        
+        if Gem::Version.new(redis_version) >= Gem::Version.new('6.0.0')
+          begin
+            acl_info = connection.call('ACL', 'LIST')
+            default_user = acl_info.grep(/default/).first
+            
+            if default_user.include?('on') && default_user.include?('nopass')
+              return "Administrator (open access)"
+            elsif default_user.include?('on') && default_user.include?('~*')
+              return "Administrator (password protected)"
+            elsif default_user.include?('allkeys')
+              if default_user.include?('allcommands')
+                return "Full access (all commands, all keys)"
+              else
+                return "Limited command access (all keys)"
+              end
+            else
+              if default_user.include?('reset')
+                "No access (default rights)"
+              else
+                "Custom ACL pattern"
+              end
+            end
+          rescue => e
+            # Try to determine rights by test commands for older Redis
+            self.generic_redis_access_check
+          end
+        else
+          # Older Redis version
+          self.generic_redis_access_check
+        end
+      end
+      
+      def generic_redis_access_check
+        # Check for admin commands
+        admin_access = false
+        begin
+          # Try an admin command (CONFIG GET)
+          connection.call('CONFIG', 'GET', 'maxmemory')
+          admin_access = true
+        rescue => e
+          admin_access = false
+        end
+        
+        # Check for write ability
+        write_access = false
+        begin
+          # Use a random key name to avoid conflicts
+          test_key = "__test_key_#{rand(1000000)}"
+          connection.call('SET', test_key, 'test_value')
+          connection.call('DEL', test_key)
+          write_access = true
+        rescue => e
+          write_access = false
+        end
+        
+        if admin_access
+          "Administrator (config access)"
+        elsif write_access
+          "Regular user (read/write)"
+        else
+          # Try a read command
+          begin
+            connection.call('PING')
+            "Read-only user"
+          rescue => e
+            "Limited access"
+          end
+        end
+      end
     end
   end
   

data/lib/detector/addons/smtp.rb

@@ -32,6 +32,28 @@ module Detector
       def cli_name
         "telnet"
       end
+      
+      def user_access_level
+        return nil unless connection
+        
+        # For SMTP, limited testing is possible
+        # We know we have authenticated access already if connection exists
+        
+        # Try to validate recipient (admin-level feature)
+        admin_level = false
+        begin
+          connection.vrfy("postmaster")
+          admin_level = true
+        rescue => e
+          admin_level = false
+        end
+        
+        if admin_level
+          "Administrator (VRFY command allowed)"
+        else
+          "Authenticated user (send mail)"
+        end
+      end
     end
   end
   

data/lib/detector/base.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'geocoder'
 
 module Detector
   class Base
@@ -94,6 +95,221 @@ module Detector
       nil
     end
     
+    def geo
+      return nil unless valid?
+      @geo ||= Geocoder.search(ip).first
+    end
+    
+    # Lookup the location for the IP:
+    def geography
+      return nil unless valid?
+      "#{geo.city}, #{geo.region}, #{geo.country}" if geo
+    end
+    
+    def region
+      return nil unless valid?
+      
+      # Try to determine region from hostname first
+      hostname = host.to_s.downcase
+      
+      # AWS regions from hostname
+      if hostname =~ /amazonaws\.com/ || hostname =~ /aws/
+        return "us-east-1" if hostname =~ /us-east-1|virginia|nova/
+        return "us-east-2" if hostname =~ /us-east-2|ohio/
+        return "us-west-1" if hostname =~ /us-west-1|california|norcal/
+        return "us-west-2" if hostname =~ /us-west-2|oregon/
+        return "af-south-1" if hostname =~ /af-south|cape-town/
+        return "ap-east-1" if hostname =~ /ap-east|hong-kong/
+        return "ap-south-1" if hostname =~ /ap-south|mumbai/
+        return "ap-northeast-1" if hostname =~ /ap-northeast-1|tokyo/
+        return "ap-northeast-2" if hostname =~ /ap-northeast-2|seoul/
+        return "ap-northeast-3" if hostname =~ /ap-northeast-3|osaka/
+        return "ap-southeast-1" if hostname =~ /ap-southeast-1|singapore/
+        return "ap-southeast-2" if hostname =~ /ap-southeast-2|sydney/
+        return "ca-central-1" if hostname =~ /ca-central|canada|montreal/
+        return "eu-central-1" if hostname =~ /eu-central-1|frankfurt/
+        return "eu-west-1" if hostname =~ /eu-west-1|ireland|dublin/
+        return "eu-west-2" if hostname =~ /eu-west-2|london/
+        return "eu-west-3" if hostname =~ /eu-west-3|paris/
+        return "eu-north-1" if hostname =~ /eu-north-1|stockholm/
+        return "eu-south-1" if hostname =~ /eu-south-1|milan/
+        return "me-south-1" if hostname =~ /me-south-1|bahrain/
+        return "sa-east-1" if hostname =~ /sa-east-1|sao-paulo/
+      end
+      
+      # Azure regions from hostname
+      if hostname =~ /azure|windows\.net|cloudapp/
+        return "eastus" if hostname =~ /eastus|virginia/
+        return "eastus2" if hostname =~ /eastus2/
+        return "centralus" if hostname =~ /centralus|iowa/
+        return "northcentralus" if hostname =~ /northcentralus|illinois/
+        return "southcentralus" if hostname =~ /southcentralus|texas/
+        return "westus" if hostname =~ /westus|california/
+        return "westus2" if hostname =~ /westus2|washington/
+        return "westus3" if hostname =~ /westus3|phoenix/
+        return "australiaeast" if hostname =~ /australiaeast|sydney/
+        return "brazilsouth" if hostname =~ /brazilsouth|sao-paulo/
+        return "canadacentral" if hostname =~ /canadacentral|toronto/
+        return "centralindia" if hostname =~ /centralindia|pune/
+        return "eastasia" if hostname =~ /eastasia|hong-kong/
+        return "francecentral" if hostname =~ /francecentral|paris/
+        return "germanywestcentral" if hostname =~ /germanywestcentral|frankfurt/
+        return "japaneast" if hostname =~ /japaneast|tokyo/
+        return "koreacentral" if hostname =~ /koreacentral|seoul/
+        return "northeurope" if hostname =~ /northeurope|ireland/
+        return "southeastasia" if hostname =~ /southeastasia|singapore/
+        return "southindia" if hostname =~ /southindia|chennai/
+        return "swedencentral" if hostname =~ /swedencentral|stockholm/
+        return "switzerlandnorth" if hostname =~ /switzerlandnorth|zurich/
+        return "uksouth" if hostname =~ /uksouth|london/
+        return "westeurope" if hostname =~ /westeurope|netherlands/
+      end
+      
+      # Google Cloud regions from hostname
+      if hostname =~ /google|googlecloud|gcp|appspot/
+        return "us-central1" if hostname =~ /us-central1|iowa/
+        return "us-east1" if hostname =~ /us-east1|south-carolina/
+        return "us-east4" if hostname =~ /us-east4|virginia/
+        return "us-west1" if hostname =~ /us-west1|oregon/
+        return "us-west2" if hostname =~ /us-west2|los-angeles/
+        return "us-west3" if hostname =~ /us-west3|salt-lake-city/
+        return "us-west4" if hostname =~ /us-west4|las-vegas/
+        return "northamerica-northeast1" if hostname =~ /northamerica-northeast1|montreal/
+        return "southamerica-east1" if hostname =~ /southamerica-east1|sao-paulo/
+        return "europe-west1" if hostname =~ /europe-west1|belgium/
+        return "europe-west2" if hostname =~ /europe-west2|london/
+        return "europe-west3" if hostname =~ /europe-west3|frankfurt/
+        return "europe-west4" if hostname =~ /europe-west4|netherlands/
+        return "europe-west6" if hostname =~ /europe-west6|zurich/
+        return "europe-north1" if hostname =~ /europe-north1|finland/
+        return "asia-east1" if hostname =~ /asia-east1|taiwan/
+        return "asia-east2" if hostname =~ /asia-east2|hong-kong/
+        return "asia-northeast1" if hostname =~ /asia-northeast1|tokyo/
+        return "asia-northeast2" if hostname =~ /asia-northeast2|osaka/
+        return "asia-northeast3" if hostname =~ /asia-northeast3|seoul/
+        return "asia-south1" if hostname =~ /asia-south1|mumbai/
+        return "asia-southeast1" if hostname =~ /asia-southeast1|singapore/
+        return "asia-southeast2" if hostname =~ /asia-southeast2|jakarta/
+        return "australia-southeast1" if hostname =~ /australia-southeast1|sydney/
+      end
+      
+      # Fallback to IP-based lookup via Geocoder
+      return nil unless geo
+      
+      # City-based detection for common cloud cities
+      city = geo&.data&.dig('city')&.downcase
+      if city
+        case city
+        when 'ashburn', 'sterling', 'herndon', 'chantilly'
+          return "us-east-1" # AWS us-east-1 or equivalent
+        when 'columbus', 'dublin', 'hilliard'
+          return "us-east-2" # AWS us-east-2
+        when 'san jose', 'santa clara', 'milpitas', 'fremont'
+          return "us-west-1" # AWS us-west-1
+        when 'portland', 'hillsboro', 'prineville', 'the dalles'
+          return "us-west-2" # AWS us-west-2 / GCP us-west1
+        when 'phoenix', 'tempe', 'mesa'
+          return "westus3" # Azure westus3
+        when 'dallas', 'fort worth', 'san antonio'
+          return "southcentralus" # Azure southcentralus
+        when 'montreal', 'beauharnois', 'quebec'
+          return "ca-central-1" # AWS ca-central-1
+        when 'toronto'
+          return "canadacentral" # Azure canadacentral
+        when 'frankfurt', 'munich'
+          return "eu-central-1" # AWS eu-central-1
+        when 'london'
+          return "eu-west-2" # AWS eu-west-2
+        when 'paris'
+          return "eu-west-3" # AWS eu-west-3
+        when 'dublin', 'clondalkin'
+          return "eu-west-1" # AWS eu-west-1
+        when 'stockholm'
+          return "eu-north-1" # AWS eu-north-1
+        when 'milan'
+          return "eu-south-1" # AWS eu-south-1
+        when 'sydney', 'melbourne'
+          return "ap-southeast-2" # AWS ap-southeast-2
+        when 'singapore'
+          return "ap-southeast-1" # AWS ap-southeast-1
+        when 'tokyo', 'osaka'
+          return "ap-northeast-1" # AWS ap-northeast-1
+        when 'seoul'
+          return "ap-northeast-2" # AWS ap-northeast-2
+        when 'mumbai'
+          return "ap-south-1" # AWS ap-south-1
+        when 'hong kong'
+          return "ap-east-1" # AWS ap-east-1
+        when 'são paulo', 'sao paulo'
+          return "sa-east-1" # AWS sa-east-1
+        end
+      end
+      
+      # Region/State-based mapping to approximate cloud region
+      region_name = geo&.data&.dig('region')
+      country = geo&.data&.dig('country')
+      
+      if country == 'United States'
+        case region_name
+        when 'Virginia', 'Maryland', 'District of Columbia'
+          return "us-east-1"
+        when 'Ohio', 'Indiana', 'Michigan'
+          return "us-east-2"
+        when 'California'
+          return "us-west-1"
+        when 'Oregon', 'Washington', 'Idaho'
+          return "us-west-2"
+        when 'Nevada', 'Utah', 'Arizona'
+          return "us-west-2"
+        when 'Texas', 'Oklahoma', 'Louisiana'
+          return "southcentralus"
+        when 'Illinois', 'Iowa', 'Minnesota', 'Missouri', 'Wisconsin'
+          return "us-central1"
+        end
+      elsif country == 'Canada'
+        case region_name
+        when 'Quebec'
+          return "ca-central-1"
+        when 'Ontario'
+          return "canadacentral"
+        end
+      elsif country == 'Brazil'
+        return "sa-east-1"
+      elsif country == 'Ireland'
+        return "eu-west-1"
+      elsif country == 'United Kingdom'
+        return "eu-west-2"
+      elsif country == 'France'
+        return "eu-west-3"
+      elsif country == 'Germany'
+        return "eu-central-1"
+      elsif country == 'Sweden' || country == 'Norway' || country == 'Finland'
+        return "eu-north-1"
+      elsif country == 'Italy'
+        return "eu-south-1"
+      elsif country == 'India'
+        return "ap-south-1"
+      elsif country == 'Singapore'
+        return "ap-southeast-1"
+      elsif country == 'Australia'
+        return "ap-southeast-2"
+      elsif country == 'Japan'
+        return "ap-northeast-1"
+      elsif country == 'South Korea'
+        return "ap-northeast-2"
+      elsif country == 'Hong Kong'
+        return "ap-east-1"
+      end
+      
+      # Final fallback
+      region_name || geo&.data&.dig('country_code')&.downcase
+    end
+    
+    def asn
+      return nil unless valid?
+      geo&.data&.dig('org')&.split(" ")&.first
+    end
+    
     def connection?
       connection.present?
     end
@@ -138,5 +354,87 @@ module Detector
     def usage
       nil
     end
+    
+    def user_access_level
+      return nil unless valid? && connection?
+      "Unknown"
+    end
+    
+    def infrastructure
+      return nil unless valid?
+      
+      hostname = host.to_s.downcase
+      case hostname
+      when /amazon/, /aws/, /amazonaws/, /ec2/, /s3/, /dynamodb/, /rds\./, /elasticbeanstalk/
+        "Amazon Web Services"
+      when /google/, /googlecloud/, /appspot/, /gcp/, /compute\./, /cloud\.g/
+        "Google Cloud Platform"
+      when /azure/, /azurewebsites/, /cloudapp\./, /windows\.net/
+        "Microsoft Azure"
+      when /antimony/
+        "Build.io"
+      when /heroku/, /herokuapp/
+        "Heroku"
+      when /digitalocean/, /droplet/
+        "DigitalOcean"
+      when /linode/, /linodeobjects/
+        "Linode"
+      when /vultr/
+        "Vultr"
+      when /netlify/
+        "Netlify"
+      when /vercel/, /zeit\.co/, /now\.sh/
+        "Vercel"
+      when /github\.io/, /githubusercontent/, /github\.dev/
+        "GitHub"
+      when /gitlab\.io/, /gitlab-static/
+        "GitLab"
+      when /oracle/, /oraclecloud/
+        "Oracle Cloud"
+      when /ibm/, /bluemix/, /ibmcloud/
+        "IBM Cloud"
+      when /cloudflare/, /workers\.dev/
+        "Cloudflare"
+      when /fastly/
+        "Fastly"
+      when /akamai/
+        "Akamai"
+      when /render\.com/
+        "Render"
+      when /fly\.io/
+        "Fly.io"
+      when /railway\.app/
+        "Railway"
+      when /upcloud/
+        "UpCloud"
+      when /hetzner/
+        "Hetzner"
+      when /ovh/, /ovhcloud/
+        "OVH"
+      when /scaleway/
+        "Scaleway"
+      when /contabo/
+        "Contabo"
+      when /dreamhost/
+        "DreamHost"
+      when /hostgator/
+        "HostGator"
+      when /bluehost/
+        "Bluehost"
+      when /siteground/
+        "SiteGround"
+      when /namecheap/
+        "Namecheap"
+      when /godaddy/
+        "GoDaddy"
+      when /ionos/
+        "IONOS"
+      when /hostinger/
+        "Hostinger"
+      else
+        # If geo data available, return organization, otherwise nil
+        geo&.data&.dig('org')
+      end
+    end
   end
 end 

data/lib/detector/version.rb

@@ -1,3 +1,3 @@
 module Detector
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: detector
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Jonathan Siegel
@@ -108,6 +108,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: geocoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  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: rspec
   requirement: !ruby/object:Gem::Requirement