ipapi-rb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f349f84933eea258dba2b8e92e17f5ed04ac800998135182da92c17d6222724c
+  data.tar.gz: cd78e6d317b289099ce5cfd806eb94cda1f4a10d4cfc8071e15c0c0ab06b92f3
+SHA512:
+  metadata.gz: 5ab6b4f1d3d25bd53fde29cfa798e32b8fc22c88c0cf07ee5285440ad7dfe631811116da8be4fdc5042c09b77eddce0743293897e1d82cbe45a9359aef63efc9
+  data.tar.gz: 536ce8dee48bacda8d431fd8dcdda67d21edd0330bf0d54f1a376fa8384e76b0077ba1a929143bf8226045c0f6572f114037928d56d6450717ee06c9d918ef82

data/README.md

@@ -0,0 +1,325 @@
+# IpApi
+
+The **IpApi** gem provides a Ruby interface to the [IP-API.com](https://ip-api.com) geolocation API, enabling IP address and domain lookups to retrieve location, network, and connection information.
+
+```ruby
+require 'ip_api'
+
+response = IpApi.query( '8.8.8.8' )
+if response.success?
+  result = response.result
+  puts "#{ result.city }, #{ result.country }"  # => "Ashburn, United States"
+  puts result.isp                                # => "Google LLC"
+  puts result.coordinates                        # => [39.03, -77.5]
+end
+```
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Command Line](#command-line)
+- [Quick Start](#quick-start)
+- [Free vs Pro](#free-vs-pro)
+- [Options](#options)
+  - [Fields](#fields)
+  - [Language](#language)
+- [Response](#response)
+  - [Location Fields](#location-fields)
+  - [Network Fields](#network-fields)
+  - [Connection Fields](#connection-fields)
+  - [Helper Methods](#helper-methods)
+- [Error Handling](#error-handling)
+- [Connections](#connections)
+- [License](#license)
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ipapi-rb'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install ipapi-rb
+```
+
+## Command Line
+
+The gem includes an `ipapi` command for quick lookups from the terminal:
+
+```bash
+ipapi 8.8.8.8
+ipapi google.com
+ipapi                           # Look up your own IP
+ipapi -f country,city 8.8.8.8   # Specific fields only
+ipapi -l de 8.8.8.8             # German localization
+ipapi -j 8.8.8.8                # Raw JSON output
+```
+
+Set your Pro API key via environment variable for HTTPS and unlimited requests:
+
+```bash
+export IPAPI_API_KEY=your_api_key
+```
+
+## Quick Start
+
+The simplest way to use the gem is through the module-level convenience method:
+
+```ruby
+require 'ip_api'
+
+# Query an IP address
+response = IpApi.query( '8.8.8.8' )
+if response.success?
+  result = response.result
+  puts result.country       # => "United States"
+  puts result.city          # => "Ashburn"
+  puts result.isp           # => "Google LLC"
+  puts result.hosting?      # => true
+end
+
+# Query a domain
+response = IpApi.query( 'google.com' )
+
+# Query your own IP (no argument)
+response = IpApi.query
+```
+
+For more control, instantiate request objects directly:
+
+```ruby
+request = IpApi::QueryRequest.new( api_key: ENV[ 'IPAPI_API_KEY' ] )
+
+options = IpApi::QueryOptions.build do
+  fields [ :country, :city, :isp, :proxy, :hosting ]
+  lang :de
+end
+
+response = request.submit( '8.8.8.8', options )
+```
+
+---
+
+## Free vs Pro
+
+The gem automatically selects the appropriate endpoint based on whether an API key is configured:
+
+| Feature | Free | Pro |
+|---------|------|-----|
+| **Endpoint** | `http://ip-api.com` | `https://pro.ip-api.com` |
+| **SSL/HTTPS** | No | Yes |
+| **Rate Limit** | 45 requests/minute | Unlimited |
+| **Commercial Use** | No | Yes |
+
+```ruby
+# Free (no API key)
+response = IpApi.query( '8.8.8.8' )
+
+# Pro (with API key)
+IpApi.api_key ENV[ 'IPAPI_API_KEY' ]
+response = IpApi.query( '8.8.8.8' )
+
+# Or pass directly to request
+request = IpApi::QueryRequest.new( api_key: 'your-key' )
+response = request.submit( '8.8.8.8' )
+```
+
+---
+
+## Options
+
+### Fields
+
+Control which fields are returned to reduce bandwidth:
+
+```ruby
+options = IpApi::QueryOptions.build do
+  fields [ :status, :country, :city, :lat, :lon ]
+end
+
+response = IpApi.query( '8.8.8.8', options )
+```
+
+Available fields (use snake_case in Ruby):
+
+| Field | Description |
+|-------|-------------|
+| `:status` | Request status (`success` or `fail`) |
+| `:message` | Error message (when status is `fail`) |
+| `:query` | IP address used for the query |
+| `:continent` | Continent name |
+| `:continent_code` | Two-letter continent code |
+| `:country` | Country name |
+| `:country_code` | ISO 3166-1 alpha-2 country code |
+| `:region` | Region/state short code |
+| `:region_name` | Region/state full name |
+| `:city` | City name |
+| `:district` | District (subdivision of city) |
+| `:zip` | Zip/postal code |
+| `:lat` | Latitude |
+| `:lon` | Longitude |
+| `:timezone` | Timezone identifier |
+| `:offset` | UTC offset in seconds |
+| `:currency` | National currency code |
+| `:isp` | ISP name |
+| `:org` | Organization name |
+| `:as` | AS number and organization |
+| `:as_name` | AS name |
+| `:reverse` | Reverse DNS (can delay response) |
+| `:mobile` | Mobile connection flag |
+| `:proxy` | Proxy/VPN/Tor flag |
+| `:hosting` | Hosting/datacenter flag |
+
+### Language
+
+Localize the `country`, `region_name`, and `city` fields:
+
+```ruby
+options = IpApi::QueryOptions.build do
+  lang :de  # German
+end
+
+response = IpApi.query( '8.8.8.8', options )
+puts response.result.country  # => "Vereinigte Staaten"
+```
+
+Supported languages: `:en`, `:de`, `:es`, `:fr`, `:ja`, `:ru`, `:'pt-BR'`, `:'zh-CN'`
+
+---
+
+## Response
+
+### Location Fields
+
+```ruby
+result = response.result
+
+result.continent        # => "North America"
+result.continent_code   # => "NA"
+result.country          # => "United States"
+result.country_code     # => "US"
+result.region           # => "VA"
+result.region_name      # => "Virginia"
+result.city             # => "Ashburn"
+result.district         # => nil
+result.zip              # => "20149"
+result.lat              # => 39.03
+result.lon              # => -77.5
+result.timezone         # => "America/New_York"
+result.offset           # => -18000
+result.currency         # => "USD"
+```
+
+### Network Fields
+
+```ruby
+result.isp              # => "Google LLC"
+result.org              # => "Google Public DNS"
+result.as_number        # => "AS15169 Google LLC"
+result.as_name          # => "GOOGLE"
+result.reverse          # => "dns.google"
+```
+
+### Connection Fields
+
+```ruby
+result.mobile           # => false
+result.proxy            # => false
+result.hosting          # => true
+```
+
+### Helper Methods
+
+```ruby
+result.success?         # => true (status == 'success')
+result.failed?          # => false (status == 'fail')
+
+result.mobile?          # => false
+result.proxy?           # => false
+result.hosting?         # => true
+
+result.coordinates      # => [39.03, -77.5]
+```
+
+---
+
+## Error Handling
+
+The API returns errors in two ways:
+
+**HTTP errors** (rate limiting):
+
+```ruby
+response = IpApi.query( '8.8.8.8' )
+
+unless response.success?
+  error = response.result
+  puts error.error_type         # => :rate_limit_error
+  puts error.error_description  # => "The rate limit has been exceeded..."
+end
+```
+
+**API errors** (invalid query, private IP):
+
+```ruby
+response = IpApi.query( '192.168.1.1' )
+
+if response.success?
+  result = response.result
+  if result.failed?
+    puts result.message  # => "private range"
+  end
+end
+```
+
+Common API error messages:
+
+| Message | Description |
+|---------|-------------|
+| `private range` | IP is in a private network range |
+| `reserved range` | IP is in a reserved range |
+| `invalid query` | Invalid IP or domain |
+
+---
+
+## Connections
+
+The gem uses Faraday for HTTP requests. To customize the connection:
+
+```ruby
+connection = Faraday.new do | faraday |
+  faraday.response :logger
+  faraday.adapter :net_http
+end
+
+IpApi.connection connection
+```
+
+Or pass it directly to a request:
+
+```ruby
+request = IpApi::QueryRequest.new(
+  api_key: ENV[ 'IPAPI_API_KEY' ],
+  connection: connection
+)
+```
+
+---
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/ipapi

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'ip_api'
+
+def usage
+  puts "Usage: ipapi [options] [ip_or_domain]"
+  puts
+  puts "Look up geolocation and network information for an IP address or domain."
+  puts "If no IP/domain is provided, looks up the current machine's public IP."
+  puts
+  puts "Options:"
+  puts "  -f, --fields <list>   Comma-separated fields to return"
+  puts "  -l, --lang <code>     Language for localized fields (en, de, es, fr, ja, ru, pt-BR, zh-CN)"
+  puts "  -j, --json            Output raw JSON"
+  puts "  -h, --help            Show this help message"
+  puts
+  puts "Environment:"
+  puts "  IPAPI_API_KEY         Your IP-API Pro key (optional, enables HTTPS and unlimited requests)"
+  puts
+  puts "Examples:"
+  puts "  ipapi 8.8.8.8"
+  puts "  ipapi google.com"
+  puts "  ipapi                           # Look up your own IP"
+  puts "  ipapi -f country,city 8.8.8.8"
+  puts "  ipapi -l de 8.8.8.8             # German localization"
+  puts "  ipapi -j 8.8.8.8                # Raw JSON output"
+  puts
+  puts "Available fields:"
+  puts "  status, message, query, continent, continent_code, country, country_code,"
+  puts "  region, region_name, city, district, zip, lat, lon, timezone, offset,"
+  puts "  currency, isp, org, as, as_name, reverse, mobile, proxy, hosting"
+end
+
+def parse_options( args )
+  options = {}
+  query = nil
+
+  while args.any?
+    arg = args.shift
+    case arg
+    when '-f', '--fields'
+      fields_str = args.shift
+      if fields_str
+        options[ :fields ] = fields_str.split( ',' ).map { | f | f.strip.to_sym }
+      end
+    when '-l', '--lang'
+      lang = args.shift
+      options[ :lang ] = lang.to_sym if lang
+    when '-j', '--json'
+      options[ :json ] = true
+    when '-h', '--help'
+      usage
+      exit 0
+    when /^-/
+      $stderr.puts "Unknown option: #{ arg }"
+      $stderr.puts "Run 'ipapi --help' for usage"
+      exit 1
+    else
+      query = arg
+    end
+  end
+
+  [ query, options ]
+end
+
+def format_result( result )
+  output = []
+
+  output << [ 'Query', result.query ] if result.query
+  output << [ 'Status', result.status ] if result.status
+
+  if result.failed?
+    output << [ 'Message', result.message ] if result.message
+  else
+    # Location
+    output << [ 'Continent', "#{ result.continent } (#{ result.continent_code })" ] if result.continent
+    output << [ 'Country', "#{ result.country } (#{ result.country_code })" ] if result.country
+    output << [ 'Region', "#{ result.region_name } (#{ result.region })" ] if result.region_name
+    output << [ 'City', result.city ] if result.city
+    output << [ 'District', result.district ] if result.district
+    output << [ 'ZIP', result.zip ] if result.zip
+    output << [ 'Coordinates', "#{ result.lat }, #{ result.lon }" ] if result.lat && result.lon
+    output << [ 'Timezone', result.timezone ] if result.timezone
+    output << [ 'UTC Offset', result.offset ] if result.offset
+    output << [ 'Currency', result.currency ] if result.currency
+
+    # Network
+    output << [ 'ISP', result.isp ] if result.isp
+    output << [ 'Organization', result.org ] if result.org
+    output << [ 'AS', result.as_number ] if result.as_number
+    output << [ 'AS Name', result.as_name ] if result.as_name
+    output << [ 'Reverse DNS', result.reverse ] if result.reverse
+
+    # Flags
+    flags = []
+    flags << 'Mobile' if result.mobile?
+    flags << 'Proxy/VPN' if result.proxy?
+    flags << 'Hosting' if result.hosting?
+    output << [ 'Flags', flags.join( ', ' ) ] unless flags.empty?
+  end
+
+  max_label = output.map { | label, _ | label.length }.max || 0
+  output.each do | label, value |
+    puts "#{ label.ljust( max_label ) }  #{ value }"
+  end
+end
+
+# Main
+query, options = parse_options( ARGV.dup )
+
+# Set API key from environment
+IpApi.api_key ENV[ 'IPAPI_API_KEY' ] if ENV[ 'IPAPI_API_KEY' ]
+
+# Build request options
+request_options = nil
+if options[ :fields ] || options[ :lang ]
+  request_options = IpApi::QueryOptions.build do
+    fields options[ :fields ] if options[ :fields ]
+    lang options[ :lang ] if options[ :lang ]
+  end
+end
+
+# Make request
+response = IpApi.query( query, request_options )
+
+unless response.success?
+  $stderr.puts "HTTP Error: #{ response.result.error_description }"
+  exit 1
+end
+
+result = response.result
+
+if options[ :json ]
+  require 'json'
+  puts JSON.pretty_generate( result.to_h )
+else
+  format_result( result )
+end
+
+exit( result.success? ? 0 : 1 )

data/ipapi-rb.gemspec

@@ -0,0 +1,41 @@
+require_relative 'lib/ip_api/version'
+
+Gem::Specification.new do | spec |
+
+  spec.name             = 'ipapi-rb'
+  spec.version          = IpApi::VERSION
+  spec.authors          = [ 'Kristoph Cichocki-Romanov' ]
+  spec.email            = [ 'rubygems.org@kristoph.net' ]
+
+  spec.summary          =
+    "The IpApi gem implements a lightweight interface to the IP-API.com geolocation " \
+    "API for IP address and domain lookups."
+  spec.description      =
+    "The IpApi gem implements a lightweight interface to the IP-API.com geolocation " \
+    "API. IP-API provides location and network information for any IP address or domain " \
+    "name in JSON format.\n" \
+    "\n" \
+    "This gem supports both the free endpoint (rate-limited, HTTP only) and the Pro " \
+    "endpoint (unlimited, HTTPS) with automatic endpoint selection based on API key " \
+    "presence."
+  spec.license          = 'MIT'
+  spec.homepage         = 'https://github.com/EndlessInternational/ipapi-rb'
+  spec.metadata         = {
+    'source_code_uri'   => 'https://github.com/EndlessInternational/ipapi-rb',
+    'bug_tracker_uri'   => 'https://github.com/EndlessInternational/ipapi-rb/issues',
+  }
+
+  spec.required_ruby_version = '>= 3.0'
+  spec.files            = Dir[ "lib/**/*.rb", "bin/ipapi", "LICENSE", "README.md", "ipapi-rb.gemspec" ]
+  spec.bindir           = 'bin'
+  spec.executables      = [ 'ipapi' ]
+  spec.require_paths    = [ "lib" ]
+
+  spec.add_runtime_dependency 'faraday', '~> 2'
+  spec.add_runtime_dependency 'dynamicschema', '~> 2'
+
+  spec.add_development_dependency 'minitest', '~> 5.25'
+  spec.add_development_dependency 'debug', '~> 1.9'
+  spec.add_development_dependency 'vcr', '~> 6.3'
+
+end

data/lib/ip_api/error_result.rb

@@ -0,0 +1,40 @@
+module IpApi
+  class ErrorResult
+
+    attr_reader :error_type, :error_description
+
+    def initialize( status_code, attributes = nil )
+      @status_code = status_code
+      @error_type, @error_description = status_code_to_error( status_code )
+      if attributes&.respond_to?( :[] )
+        @error_description = attributes[ :message ] if attributes[ :message ]
+      end
+    end
+
+    def success?
+      false
+    end
+
+  private
+
+    # ip-api returns HTTP 200 for most errors with status: "fail" in the body
+    # only rate limiting returns HTTP 429
+    def status_code_to_error( status_code )
+      case status_code
+      when 200
+        [ :unexpected_error,
+          "The response was successful but it did not include a valid payload." ]
+      when 429
+        [ :rate_limit_error,
+          "The rate limit has been exceeded. Free tier allows 45 requests per minute." ]
+      when 500..599
+        [ :server_error,
+          "The IP-API server encountered an error while processing the request." ]
+      else
+        [ :http_error,
+          "The IP-API service returned HTTP status code: '#{ status_code }'." ]
+      end
+    end
+
+  end
+end

data/lib/ip_api/helpers.rb

@@ -0,0 +1,8 @@
+module IpApi
+  module Helpers
+    def string_camelize( string )
+      words = string.split( /[\s_\-]/ )
+      words.map.with_index { | word, index | index.zero? ? word.downcase : word.capitalize }.join
+    end
+  end
+end

data/lib/ip_api/module_methods.rb

@@ -0,0 +1,19 @@
+module IpApi
+  module ModuleMethods
+
+    def connection( connection = nil )
+      @connection = connection if connection
+      @connection ||= Faraday.new { | builder | builder.adapter Faraday.default_adapter }
+    end
+
+    def api_key( api_key = nil )
+      @api_key = api_key || @api_key
+      @api_key
+    end
+
+    def query( query = nil, options = nil, &block )
+      IpApi::QueryRequest.new.submit( query, options, &block )
+    end
+
+  end
+end

data/lib/ip_api/query_options.rb

@@ -0,0 +1,60 @@
+module IpApi
+  class QueryOptions
+    include DynamicSchema::Definable
+    include Helpers
+
+    LANGUAGES = [ :en, :de, :es, :'pt-BR', :fr, :ja, :'zh-CN', :ru ]
+
+    FIELDS = [
+      :status, :message, :query,
+      :continent, :continent_code, :country, :country_code, :region, :region_name,
+      :city, :district, :zip, :lat, :lon, :timezone, :offset, :currency,
+      :isp, :org, :as, :as_name, :reverse,
+      :mobile, :proxy, :hosting
+    ]
+
+    schema do
+      fields            Symbol, array: true, in: FIELDS
+      lang              Symbol, in: LANGUAGES
+    end
+
+    def self.build( options = nil, &block )
+      new( api_options: builder.build( options, &block ) )
+    end
+
+    def self.build!( options = nil, &block )
+      new( api_options: builder.build!( options, &block ) )
+    end
+
+    def initialize( options = {}, api_options: nil )
+      @options = self.class.builder.build( options || {} )
+      @options = api_options.merge( @options ) if api_options
+    end
+
+    def to_h
+      @options.to_h
+    end
+
+    def to_params
+      params = {}
+      hash = to_h
+
+      if hash[ :fields ] && !hash[ :fields ].empty?
+        params[ :fields ] = hash[ :fields ].map { | f | _snake_to_camel( f ) }.join( ',' )
+      end
+
+      if hash[ :lang ]
+        params[ :lang ] = hash[ :lang ].to_s
+      end
+
+      params
+    end
+
+  private
+
+    def _snake_to_camel( value )
+      value.to_s.gsub( /_([a-z])/ ) { $1.upcase }
+    end
+
+  end
+end

data/lib/ip_api/query_request.rb

@@ -0,0 +1,26 @@
+module IpApi
+  class QueryRequest < Request
+
+    def submit( query = nil, options = nil, &block )
+      if options
+        options = options.is_a?( QueryOptions ) ? options : QueryOptions.build!( options.to_h )
+        params = options.to_params
+      else
+        params = {}
+      end
+
+      path = query ? "/json/#{ query }" : "/json/"
+      response = get( "#{ base_uri }#{ path }", params, &block )
+      attributes = ( JSON.parse( response.body, symbolize_names: true ) rescue nil )
+
+      result = if response.success? && attributes
+        QueryResult.new( attributes )
+      else
+        ErrorResult.new( response.status, attributes )
+      end
+
+      ResponseMethods.install( response, result )
+    end
+
+  end
+end

data/lib/ip_api/query_result.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+
+module IpApi
+
+  QueryResultSchema = DynamicSchema::Struct.define do
+    status            String
+    message           String
+    query             String
+
+    continent         String
+    continent_code    String, as: :continentCode
+    country           String
+    country_code      String, as: :countryCode
+    region            String
+    region_name       String, as: :regionName
+    city              String
+    district          String
+    zip               String
+    lat               Float
+    lon               Float
+    timezone          String
+    offset            Integer
+    currency          String
+
+    isp               String
+    org               String
+    as_number         String, as: :as
+    as_name           String, as: :asname
+    reverse           String
+
+    mobile            [ TrueClass, FalseClass ]
+    proxy             [ TrueClass, FalseClass ]
+    hosting           [ TrueClass, FalseClass ]
+  end
+
+  class QueryResult < QueryResultSchema
+
+    def success?
+      status == 'success'
+    end
+
+    def failed?
+      status == 'fail'
+    end
+
+    def mobile?
+      mobile == true
+    end
+
+    def proxy?
+      proxy == true
+    end
+
+    def hosting?
+      hosting == true
+    end
+
+    def coordinates
+      [ lat, lon ] if lat && lon
+    end
+
+  end
+
+end

data/lib/ip_api/request.rb

@@ -0,0 +1,32 @@
+module IpApi
+  class Request
+
+    FREE_BASE_URI = 'http://ip-api.com'.freeze
+    PRO_BASE_URI = 'https://pro.ip-api.com'.freeze
+
+    def initialize( connection: nil, api_key: nil )
+      @connection = connection || IpApi.connection
+      @api_key = api_key || IpApi.api_key
+    end
+
+    def pro?
+      !@api_key.nil? && !@api_key.empty?
+    end
+
+    def base_uri
+      pro? ? PRO_BASE_URI : FREE_BASE_URI
+    end
+
+  protected
+
+    def get( uri, params = {}, &block )
+      params[ :key ] = @api_key if pro?
+
+      @connection.get( uri ) do | request |
+        request.params = params unless params.empty?
+        block.call( request ) if block
+      end
+    end
+
+  end
+end

data/lib/ip_api/response_methods.rb

@@ -0,0 +1,12 @@
+module IpApi
+  module ResponseMethods
+    def self.install( response, result )
+      response.instance_variable_set( "@_ip_api_result", result )
+      response.extend( ResponseMethods )
+    end
+
+    def result
+      @_ip_api_result
+    end
+  end
+end

data/lib/ip_api/version.rb

@@ -0,0 +1,3 @@
+module IpApi
+  VERSION = '1.0.0'
+end

data/lib/ip_api.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'uri'
+
+require 'faraday'
+require 'dynamic_schema'
+
+require_relative 'ip_api/version'
+
+require_relative 'ip_api/helpers'
+require_relative 'ip_api/error_result'
+require_relative 'ip_api/request'
+require_relative 'ip_api/response_methods'
+
+require_relative 'ip_api/query_options'
+require_relative 'ip_api/query_result'
+require_relative 'ip_api/query_request'
+
+require_relative 'ip_api/module_methods'
+
+module IpApi
+  extend ModuleMethods
+end

data/lib/ipapi-rb.rb

@@ -0,0 +1 @@
+require_relative 'ip_api'

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: ipapi-rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kristoph Cichocki-Romanov
+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: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: dynamicschema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+description: |-
+  The IpApi gem implements a lightweight interface to the IP-API.com geolocation API. IP-API provides location and network information for any IP address or domain name in JSON format.
+
+  This gem supports both the free endpoint (rate-limited, HTTP only) and the Pro endpoint (unlimited, HTTPS) with automatic endpoint selection based on API key presence.
+email:
+- rubygems.org@kristoph.net
+executables:
+- ipapi
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/ipapi
+- ipapi-rb.gemspec
+- lib/ip_api.rb
+- lib/ip_api/error_result.rb
+- lib/ip_api/helpers.rb
+- lib/ip_api/module_methods.rb
+- lib/ip_api/query_options.rb
+- lib/ip_api/query_request.rb
+- lib/ip_api/query_result.rb
+- lib/ip_api/request.rb
+- lib/ip_api/response_methods.rb
+- lib/ip_api/version.rb
+- lib/ipapi-rb.rb
+homepage: https://github.com/EndlessInternational/ipapi-rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/EndlessInternational/ipapi-rb
+  bug_tracker_uri: https://github.com/EndlessInternational/ipapi-rb/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: The IpApi gem implements a lightweight interface to the IP-API.com geolocation
+  API for IP address and domain lookups.
+test_files: []