ipwho 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e879b527d7bf970cb0fd5cd763a753a1caacf26c39943712c69369850d811e3
+  data.tar.gz: fc7de3f5d4cd2c1b486923acd619a5a84ccf3efa1446b2c2dc8c885d36d9cb52
+SHA512:
+  metadata.gz: f99e60ee24f0a0e9ae4fae090c77b1a4cc091d627febd96688b1d366652ce241faf272c7325b297b12e56afb46b0da180fa85c555c53c114ea21b00634039969
+  data.tar.gz: d55b91b8880d2758a77398f6aac7e07a37ac446187184e2da80c818785935a416cd888eb84ca3dc263107772e5c3359990d4c51099f0a16c19142baabbed1845

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## [1.0.0] - 2026-08-15
+
+- `IpwhoApi::Client` with `lookup`, `me`, and `bulk` for [api.ipwho.org](https://api.ipwho.org)
+- Full typed Struct models for geo, timezone, flag, currency, connection, security, and user-agent

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IPWho Contributors
+
+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,206 @@
+# IPWho ([ipwho.org](https://www.ipwho.org)) Ruby SDK
+
+[![Gem version](https://img.shields.io/gem/v/ipwho?style=flat-square)](https://rubygems.org/gems/ipwho) [![Ruby version](https://img.shields.io/badge/ruby-2.5+-red.svg)](https://www.ruby-lang.org/) [![license](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/lavrox/SDK-IPWho-IP-Geolocation-Ruby/blob/main/LICENSE)
+
+Official Ruby SDK for the [IPWho](https://www.ipwho.org) **IP geolocation API** — geoip lookup, IP location, IP to country / latitude / longitude, ASN/ISP, timezone, currency, flag, and proxy/VPN detection. Works as an IP lookup / ip-geolocation client for IPv4 and IPv6 (`lookup`, `me`, `bulk`).
+
+- Product: [ipwho.org](https://www.ipwho.org)
+- API docs: [ipwho.org/docs](https://www.ipwho.org/docs)
+- Get an API key: [ipwho.org/free-plan](https://www.ipwho.org/free-plan) (free [Lavrox](https://lavrox.com) account)
+- Live API host: `https://api.ipwho.org`
+
+## API key
+
+Open a free [Lavrox](https://lavrox.com) account to get an API key for [IPWho](https://www.ipwho.org). Create your key at [ipwho.org/free-plan](https://www.ipwho.org/free-plan) — no credit card required.
+
+## Installation
+
+```bash
+gem install ipwho
+```
+
+```ruby
+gem "ipwho"
+```
+
+Requires Ruby >= 2.5 and Faraday. Client class: `IpwhoApi::Client`.
+
+## Quick Start
+
+```ruby
+require "ipwho"
+
+client = IpwhoApi::Client.new(ENV.fetch("IPWHO_API_KEY"))
+
+res  = client.lookup("8.8.8.8")                  # GET /ip/{ip}
+me   = client.me                                 # GET /me
+bulk = client.bulk(["8.8.8.8", "1.1.1.1"])       # GET /bulk/{a,b,c}
+```
+
+Successful JSON:
+
+```
+IpwhoApi::IpGeoResponse
+├── success
+├── message
+└── data  (GeoData, or OpenStruct on bulk)
+    ├── ip
+    ├── geoLocation
+    ├── timezone
+    ├── flag
+    ├── currency
+    ├── connection
+    ├── security
+    ├── userAgent
+    └── responseArray   # bulk
+```
+
+## Reading the full response (8.8.8.8)
+
+Live [IPWho](https://www.ipwho.org) values: United States, ASN 15169, America/Chicago, dial code +1.
+
+```ruby
+res  = client.lookup("8.8.8.8")
+data = res.data
+
+puts data.ip # 8.8.8.8
+
+geo = data.geoLocation
+puts geo.continent, geo.continentCode # North America, NA
+puts geo.country, geo.countryCode     # United States, US
+puts geo.capital, geo.region, geo.regionCode, geo.city
+puts geo.postalCode, geo.dialCode     # +1
+puts geo.isInEu, geo.latitude, geo.longitude, geo.accuracyRadius
+
+tz = data.timezone
+puts tz.timeZone # America/Chicago
+puts tz.abbr, tz.offset, tz.isDst, tz.utc, tz.currentTime
+
+puts data.flag.flagIcon    # 🇺🇸
+puts data.flag.flagUnicode # U+1F1FA U+1F1F8
+
+puts data.currency.code, data.currency.symbol, data.currency.name
+puts data.currency.namePlural # US dollars
+puts data.currency.hexUnicode
+
+conn = data.connection
+puts conn.asnNumber      # 15169
+puts conn.asnOrg         # Google LLC
+puts conn.isp, conn.org, conn.domain
+puts conn.connectionType # Corporate
+
+puts data.security.isVpn, data.security.isTor, data.security.isThreat
+
+if data.userAgent
+  puts data.userAgent.browser.name, data.userAgent.os.name
+end
+
+me = client.me
+puts me.data.ip
+
+bulk = client.bulk(["8.8.8.8", "1.1.1.1"])
+Array(bulk.data.responseArray).each do |item|
+  puts item.data.ip, item.data.geoLocation.country
+end
+```
+
+### Example JSON (mapped fields)
+
+```json
+{
+  "success": true,
+  "data": {
+    "ip": "8.8.8.8",
+    "geoLocation": {
+      "country": "United States",
+      "countryCode": "US",
+      "dialCode": "+1",
+      "isInEu": false
+    },
+    "timezone": { "timeZone": "America/Chicago" },
+    "flag": { "flagIcon": "🇺🇸", "flagUnicode": "U+1F1FA U+1F1F8" },
+    "currency": { "code": "USD", "namePlural": "US dollars" },
+    "connection": {
+      "asnNumber": 15169,
+      "asnOrg": "Google LLC",
+      "connectionType": "Corporate"
+    },
+    "security": { "isVpn": false, "isTor": false, "isThreat": "low" }
+  }
+}
+```
+
+## API Reference
+
+### `IpwhoApi::Client.new(api_key, options = {})`
+
+Required key (query `apiKey`). `options[:base_url]` default `https://api.ipwho.org`. `options[:timeout]` default `30`.
+
+### `lookup(ip, options = {})`
+
+`options[:format]` json|xml|csv. `options[:fields]` comma-separated filter.
+
+### `me(options = {})`
+
+### `bulk(ips)`
+
+Per-IP rows on `data.responseArray`.
+
+### Errors
+
+`IpwhoApi::InvalidIPError` (404), `RateLimitError` (429), `APIResponseError`.
+
+## Type Definitions
+
+Structs (keyword init):
+
+- **GeoLocation**: `continent`, `continentCode`, `country`, `countryCode`, `capital`, `region`, `regionCode`, `city`, `postalCode`, `dialCode`, `isInEu`, `latitude`, `longitude`, `accuracyRadius`
+- **Timezone**: `timeZone`, `abbr`, `offset`, `isDst`, `utc`, `currentTime`
+- **Flag**: `flagIcon`, `flagUnicode`
+- **Currency**: `code`, `symbol`, `name`, `namePlural`, `hexUnicode`
+- **Connection**: `asnNumber`, `asnOrg`, `isp`, `org`, `domain`, `connectionType`
+- **Security**: `isVpn`, `isTor`, `isThreat`
+- **UserAgent**: `browser`, `engine`, `os`, `device`, `cpu`
+- **GeoData**: `ip` plus the objects above
+- **IpGeoResponse**: `success`, `data`, `message`
+
+Wire keys such as `postal_Code` and `flag_Icon` are mapped onto these members.
+
+## Troubleshooting
+
+- Empty key → `APIResponseError`. Key: [ipwho.org](https://www.ipwho.org).
+- HTTP 403: SDK sends `ipwho-ruby-sdk/1.0.0`.
+- HTTP 429 / 404: `RateLimitError` / `InvalidIPError`.
+- Nil nested structs on some IPs.
+
+## Testing
+
+```bash
+IPWHO_API_KEY=your_key ruby test_ipwho.rb
+```
+
+The live check is `test_ipwho.rb`.
+
+## Changelog
+
+### v1.0.0
+
+- `lookup`, `me`, `bulk` matching [api.ipwho.org](https://api.ipwho.org)
+- Full typed Struct models
+
+## License
+
+MIT License — see [LICENSE](LICENSE).
+
+## Support
+
+- Documentation: [ipwho.org/docs](https://www.ipwho.org/docs)
+- Contact: [ipwho.org/contact](https://www.ipwho.org/contact)
+- GitHub Issues: [lavrox/SDK-IPWho-IP-Geolocation-Ruby](https://github.com/lavrox/SDK-IPWho-IP-Geolocation-Ruby/issues)
+- Website: [ipwho.org](https://www.ipwho.org)
+
+---
+
+[IPWho](https://www.ipwho.org) — a [Lavrox](https://lavrox.com) network API.
+
+[Lavrox](https://lavrox.com) — Independent API infrastructure. Lower latency, lower cost.

data/lib/ipwho.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+# IPWho Ruby SDK v1.0.0
+# ======================
+#
+# Enterprise-grade client for the IPWho IP Geolocation API.
+# Requires Ruby >= 2.5, faraday ~> 1.0, json.
+#
+# Endpoints:
+#   - lookup(ip)     — geolocation for a specific IPv4/IPv6 address
+#   - me()           — geolocation for the caller's IP
+#   - bulk(ips)      — batch lookup for multiple IPs
+#
+# API docs: https://api.ipwho.org
+
+require "json"
+require "faraday"
+require "ostruct"
+require "erb"
+
+module IpwhoApi
+  VERSION = "1.0.0".freeze
+
+  # ── Exceptions ────────────────────────────────────────────────────
+
+  class Error < StandardError; end
+  class InvalidIPError < Error; end
+  class RateLimitError < Error; end
+  class APIResponseError < Error; end
+
+  # ── Data objects (Struct-based, mirror OpenAPI schema) ────────────
+
+  # All data objects use camelCase keys matching the API response.
+
+  GeoLocation = Struct.new(
+    :continent, :continentCode, :country, :countryCode, :capital,
+    :region, :regionCode, :city, :postalCode, :dialCode,
+    :isInEu, :latitude, :longitude, :accuracyRadius,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        continent:      hash["continent"],
+        continentCode:  hash["continentCode"],
+        country:        hash["country"],
+        countryCode:    hash["countryCode"],
+        capital:        hash["capital"],
+        region:         hash["region"],
+        regionCode:     hash["regionCode"],
+        city:           hash["city"],
+        postalCode:     hash["postal_Code"],
+        dialCode:       hash["dial_code"],
+        isInEu:         hash["is_in_eu"],
+        latitude:       hash["latitude"],
+        longitude:      hash["longitude"],
+        accuracyRadius: hash["accuracy_radius"]
+      )
+    end
+  end
+
+  Timezone = Struct.new(
+    :timeZone, :abbr, :offset, :isDst, :utc, :currentTime,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        timeZone:    hash["time_zone"],
+        abbr:        hash["abbr"],
+        offset:      hash["offset"],
+        isDst:       hash["is_dst"],
+        utc:         hash["utc"],
+        currentTime: hash["current_time"]
+      )
+    end
+  end
+
+  Flag = Struct.new(:flagIcon, :flagUnicode, keyword_init: true) do
+    def self.from_hash(hash)
+      new(flagIcon: hash["flag_Icon"], flagUnicode: hash["flag_unicode"])
+    end
+  end
+
+  Currency = Struct.new(
+    :code, :symbol, :name, :namePlural, :hexUnicode,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        code:       hash["code"],
+        symbol:     hash["symbol"],
+        name:       hash["name"],
+        namePlural: hash["name_plural"],
+        hexUnicode: hash["hex_unicode"]
+      )
+    end
+  end
+
+  Connection = Struct.new(
+    :asnNumber, :asnOrg, :isp, :org, :domain, :connectionType,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        asnNumber:      hash["asn_number"],
+        asnOrg:         hash["asn_org"],
+        isp:            hash["isp"],
+        org:            hash["org"],
+        domain:         hash["domain"],
+        connectionType: hash["connection_type"]
+      )
+    end
+  end
+
+  Security = Struct.new(:isVpn, :isTor, :isThreat, keyword_init: true) do
+    def self.from_hash(hash)
+      new(
+        isVpn:    hash["isVpn"],
+        isTor:    hash["isTor"],
+        isThreat: hash["isThreat"]
+      )
+    end
+  end
+
+  UserAgentBrowser = Struct.new(:name, :version, keyword_init: true) do
+    def self.from_hash(hash)
+      new(name: hash["name"], version: hash["version"])
+    end
+  end
+
+  UserAgentEngine = Struct.new(:name, :version, keyword_init: true) do
+    def self.from_hash(hash)
+      new(name: hash["name"], version: hash["version"])
+    end
+  end
+
+  UserAgentOS = Struct.new(:name, :version, keyword_init: true) do
+    def self.from_hash(hash)
+      new(name: hash["name"], version: hash["version"])
+    end
+  end
+
+  UserAgentDevice = Struct.new(:type, :vendor, :model, keyword_init: true) do
+    def self.from_hash(hash)
+      new(type: hash["type"], vendor: hash["vendor"], model: hash["model"])
+    end
+  end
+
+  UserAgentCPU = Struct.new(:architecture, keyword_init: true) do
+    def self.from_hash(hash)
+      new(architecture: hash["architecture"])
+    end
+  end
+
+  UserAgent = Struct.new(:browser, :engine, :os, :device, :cpu, keyword_init: true) do
+    def self.from_hash(hash)
+      new(
+        browser: hash["browser"] ? UserAgentBrowser.from_hash(hash["browser"]) : nil,
+        engine:  hash["engine"]  ? UserAgentEngine.from_hash(hash["engine"])   : nil,
+        os:      hash["os"]      ? UserAgentOS.from_hash(hash["os"])           : nil,
+        device:  hash["device"]  ? UserAgentDevice.from_hash(hash["device"])   : nil,
+        cpu:     hash["cpu"]     ? UserAgentCPU.from_hash(hash["cpu"])         : nil
+      )
+    end
+  end
+
+  GeoData = Struct.new(
+    :ip, :geoLocation, :timezone, :flag, :currency, :connection, :security, :userAgent,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(
+        ip:          hash["ip"] || "",
+        geoLocation: hash["geoLocation"] ? GeoLocation.from_hash(hash["geoLocation"]) : nil,
+        timezone:    hash["timezone"]    ? Timezone.from_hash(hash["timezone"])       : nil,
+        flag:        hash["flag"]        ? Flag.from_hash(hash["flag"])               : nil,
+        currency:    hash["currency"]    ? Currency.from_hash(hash["currency"])       : nil,
+        connection:  hash["connection"]  ? Connection.from_hash(hash["connection"])   : nil,
+        security:    hash["security"]    ? Security.from_hash(hash["security"])       : nil,
+        userAgent:   hash["userAgent"]   ? UserAgent.from_hash(hash["userAgent"])     : nil
+      )
+    end
+  end
+
+  ErrorResponse = Struct.new(:success, :message, keyword_init: true) do
+    def self.from_hash(hash)
+      new(success: hash["success"], message: hash["message"])
+    end
+  end
+
+  IpGeoResponse = Struct.new(:success, :data, :message, keyword_init: true) do
+    def self.from_hash(hash)
+      data_obj = nil
+      if hash["data"].is_a?(Hash)
+        # Bulk: normalise responseArray
+        if hash["data"]["responseArray"].is_a?(Array)
+          data_obj = hash["data"].dup
+          data_obj["responseArray"] = hash["data"]["responseArray"].map { |item| IpGeoResponse.from_hash(item) }
+          data_obj = OpenStruct.new(data_obj)
+        else
+          data_obj = GeoData.from_hash(hash["data"])
+        end
+      end
+      new(success: hash["success"], data: data_obj, message: hash["message"])
+    end
+  end
+
+  # ── Client ──────────────────────────────────────────────────────────
+
+  class Client
+    DEFAULT_BASE_URL = "https://api.ipwho.org".freeze
+
+    # @param api_key [String] Your IPWho API key (required).
+    # @param options [Hash]
+    # @option options [String] :base_url Override base URL (default https://api.ipwho.org).
+    # @option options [Numeric] :timeout Request timeout in seconds (default 30).
+    def initialize(api_key, options = {})
+      raise APIResponseError, "api_key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = (options[:base_url] || DEFAULT_BASE_URL).sub(%r{/+$}, "")
+      @timeout = options[:timeout] || 30
+    end
+
+    # ── public API ──────────────────────────────────────────────────
+
+    # Look up geolocation for a specific IPv4 or IPv6 address.
+    #
+    # @param ip [String] The IP address.
+    # @param options [Hash]
+    # @option options [String] :format json|xml|csv (default json)
+    # @option options [String] :fields Comma-separated fields filter
+    # @return [IpwhoApi::IpGeoResponse]
+    # @raise [IpwhoApi::InvalidIPError] – 404
+    # @raise [IpwhoApi::RateLimitError] – 429
+    # @raise [IpwhoApi::APIResponseError] – other errors
+    def lookup(ip, options = {})
+      format = options[:format] || "json"
+      params = build_params(format, options[:fields])
+      get("/ip/#{ERB::Util.url_encode(ip)}", params, format)
+    end
+
+    # Look up geolocation for the caller's own IP address.
+    #
+    # @param options [Hash]
+    # @option options [String] :format json|xml|csv (default json)
+    # @option options [String] :fields Comma-separated fields filter
+    # @return [IpwhoApi::IpGeoResponse]
+    # @raise [IpwhoApi::APIResponseError]
+    def me(options = {})
+      format = options[:format] || "json"
+      params = build_params(format, options[:fields])
+      get("/me", params, format)
+    end
+
+    # Batch-lookup multiple IP addresses.
+    #
+    # @param ips [Array<String>] List of IPv4 or IPv6 addresses.
+    # @return [IpwhoApi::IpGeoResponse] Response with data.responseArray of IpGeoResponse.
+    # @raise [IpwhoApi::APIResponseError]
+    def bulk(ips)
+      raise APIResponseError, "ips must not be empty" if ips.nil? || ips.empty?
+
+      bulk_param = ips.join(",")
+      params = { apiKey: @api_key }
+      get("/bulk/#{ERB::Util.url_encode(bulk_param)}", params, "json")
+    end
+
+    private
+
+    # Build query parameters.
+    def build_params(format, fields)
+      params = { apiKey: @api_key }
+      params[:format] = format if format != "json"
+      params[:get]    = fields if fields && !fields.empty?
+      params
+    end
+
+    # Execute a GET request and return typed response.
+    def get(path, params, format)
+      conn = Faraday.new(url: @base_url) do |f|
+        f.headers["Accept"]     = "application/json"
+        f.headers["User-Agent"] = "ipwho-ruby-sdk/#{VERSION}"
+        f.options.timeout       = @timeout
+        f.options.open_timeout  = @timeout
+        f.adapter Faraday.default_adapter
+      end
+
+      response = conn.get(path, params)
+      status   = response.status
+      body     = response.body
+
+      # Rate limit
+      raise RateLimitError, error_message(body, status) if status == 429
+
+      # Not found
+      raise InvalidIPError, error_message(body, status) if status == 404
+
+      # Other HTTP errors
+      raise APIResponseError, "HTTP #{status}: #{error_message(body, status)}" unless status >= 200 && status < 300
+
+      # Non-JSON formats: wrap raw text
+      unless format == "json"
+        return IpGeoResponse.new(
+          success: true,
+          data: GeoData.new(ip: body),
+          message: nil
+        )
+      end
+
+      # JSON success path
+      payload = JSON.parse(body)
+
+      # Logical error in success=false
+      if payload["success"] == false
+        raise APIResponseError, payload["message"] || "API returned success=false"
+      end
+
+      IpGeoResponse.from_hash(payload)
+    rescue Faraday::Error => e
+      raise APIResponseError, "Request failed: #{e.message}"
+    rescue JSON::ParserError
+      raise APIResponseError, "Invalid JSON response"
+    end
+
+    # Best-effort extraction of error message.
+    def error_message(body, _status)
+      return "Unknown API error" if body.nil? || body.empty?
+
+      parsed = JSON.parse(body) rescue nil
+      return parsed["message"] if parsed.is_a?(Hash) && parsed["message"]
+
+      body
+    end
+  end
+end
+
+# ═══════════════════════════════════════════════════════════════════════
+# Example usage
+# ═══════════════════════════════════════════════════════════════════════
+
+if __FILE__ == $PROGRAM_NAME
+  require "json"
+  require "faraday"
+  require "ostruct"
+  require "erb"
+
+  api_key = ENV["IPWHO_API_KEY"] || "sk.xxxx"
+  client = IpwhoApi::Client.new(api_key)
+
+  # Single lookup
+  resp = client.lookup("8.8.8.8")
+  if resp.data&.geoLocation
+    gl = resp.data.geoLocation
+    puts "IP: #{resp.data.ip}  |  #{gl.city}, #{gl.country} (#{gl.latitude}, #{gl.longitude})"
+  end
+  if resp.data&.currency
+    puts "Currency: #{resp.data.currency.code} (#{resp.data.currency.symbol})"
+  end
+
+  # Self lookup
+  me = client.me
+  puts "\nMy IP: #{me.data&.ip || 'unknown'}"
+
+  # Bulk
+  bulk = client.bulk(["8.8.8.8", "1.1.1.1"])
+  puts "\nBulk: success=#{bulk.success}"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: ipwho
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- IPWho SDK Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Geoip lookup, IP location, ASN/ISP, timezone, currency, flag, and VPN/proxy
+  detection for IPv4 and IPv6 via api.ipwho.org.
+email:
+- info@ipwho.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/ipwho.rb
+homepage: https://www.ipwho.org
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.ipwho.org
+  source_code_uri: https://github.com/lavrox/SDK-IPWho-IP-Geolocation-Ruby
+  changelog_uri: https://github.com/lavrox/SDK-IPWho-IP-Geolocation-Ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/lavrox/SDK-IPWho-IP-Geolocation-Ruby/issues
+  documentation_uri: https://www.ipwho.org/docs
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Official Ruby SDK for the IPWho IP geolocation API (lookup, me, bulk).
+test_files: []