truaddress 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f9fae5b2d1a641613378d6a24fa8477f01428983bc37234de5eb35f12ec1f3a4
+  data.tar.gz: 2687eb72b7182e779bf9be66b3846e0449710d4c4edb9b6feba2db737abeffae
+SHA512:
+  metadata.gz: f1a85b789f2a1537f53f6e78f7ed0e7b6d2cf9d9fb1a74cd88e736dd8cd14ad93f03d86e9d15ba62f93e0f3ec16df4fe6b52b077616680ea1a363fe4c17a61e7
+  data.tar.gz: bc548b44f3219cf093296bafef7a0532e7f396ef2d086321181c1516f43026e64eccfeeb2966d3c654a9f51706862db9875166cdc3a58056d7db4fd98a575065

data/README.md

@@ -0,0 +1,311 @@
+# TruAddress Ruby SDK
+
+Official Ruby SDK for [TruAddress](https://truaddress.net) - Address validation, autocomplete, and geocoding API.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'truaddress'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install truaddress
+```
+
+## Quick Start
+
+```ruby
+require 'truaddress'
+
+client = Truaddress::Client.new(api_key: "YOUR_API_KEY")
+
+# Validate a US address
+results = client.us_street(
+  street: "1600 Pennsylvania Ave NW",
+  city: "Washington",
+  state: "DC",
+  zipcode: "20500"
+)
+
+if results.any? && Truaddress::Client.deliverable?(results[0])
+  puts "Valid address: #{results[0]['delivery_line_1']}"
+end
+```
+
+## Configuration
+
+### Per-client Configuration
+
+```ruby
+client = Truaddress::Client.new(
+  api_key: "YOUR_API_KEY",
+  base_url: "https://truaddress.net"  # Optional
+)
+```
+
+### Global Configuration
+
+```ruby
+Truaddress.configure do |config|
+  config.api_key = "YOUR_API_KEY"
+  config.base_url = "https://truaddress.net"
+end
+
+# Then use the global client
+results = Truaddress.client.us_street(street: "350 5th Ave", city: "New York", state: "NY")
+```
+
+## Available Methods
+
+### US Endpoints
+
+#### `us_street` - US Street Address Validation
+
+```ruby
+results = client.us_street(
+  street: "350 5th Avenue",
+  city: "New York",
+  state: "NY",
+  zipcode: "10118"
+)
+
+puts results[0]["analysis"]["dpv_match_code"]  # => "Y" (Deliverable)
+puts results[0]["metadata"]["latitude"]        # => 40.748535
+```
+
+**DPV Match Codes:**
+- `Y` - Confirmed deliverable
+- `S` - Secondary (apt/suite) missing
+- `D` - Secondary invalid
+- `N` - Not deliverable
+
+#### `us_zipcode` - ZIP Code Lookup
+
+```ruby
+# By ZIP code
+result = client.us_zipcode(zipcode: "90210")
+puts result[0]["city_states"][0]["city"]  # => "Beverly Hills"
+
+# By city/state
+result = client.us_zipcode(city: "Austin", state: "TX")
+```
+
+#### `us_autocomplete` - Address Autocomplete
+
+```ruby
+result = client.us_autocomplete(
+  search: "350 5th Ave",
+  max_results: 5,
+  state_filter: ["NY"]
+)
+
+result["suggestions"].each do |s|
+  puts "#{s['street_line']}, #{s['city']}, #{s['state']} #{s['zipcode']}"
+end
+```
+
+#### `us_extract` - Extract Addresses from Text
+
+```ruby
+result = client.us_extract("Ship to: 350 5th Avenue, New York, NY 10118. Thanks!")
+
+puts result["meta"]["address_count"]      # => 1
+puts result["addresses"][0]["verified"]   # => true
+```
+
+#### `us_reverse_geo` - Reverse Geocoding
+
+```ruby
+result = client.us_reverse_geo(
+  latitude: 40.748535,
+  longitude: -73.9856571
+)
+
+result["results"].each do |r|
+  puts "#{r['address']['street']} (#{r['distance'].round}m away)"
+end
+```
+
+### International Endpoints
+
+#### `intl_street` - International Address Validation
+
+```ruby
+results = client.intl_street(
+  country: "GBR",
+  freeform: "10 Downing Street, London"
+)
+
+puts results[0]["components"]["postal_code"]         # => "SW1A 2AB"
+puts Truaddress::Client.verified?(results[0])        # => true
+```
+
+#### `intl_autocomplete` - International Autocomplete
+
+```ruby
+result = client.intl_autocomplete(
+  search: "Champs Elysees",
+  country: "FRA",
+  max_results: 5
+)
+```
+
+### Core Endpoints
+
+#### `validate` - Global Address Validation
+
+```ruby
+results = client.validate(
+  country: "US",
+  address1: "350 5th Avenue",
+  locality: "New York",
+  administrative_area: "NY",
+  postal_code: "10118"
+)
+```
+
+#### `correct` - Address Correction
+
+```ruby
+results = client.correct(freeform: "1600 pennsylvania ave washington dc 20500")
+puts results[0]["address1"]  # Corrected address
+```
+
+#### `autocomplete` - Global Autocomplete
+
+```ruby
+result = client.autocomplete(q: "Buckingham Palace London", limit: 5)
+```
+
+## Helper Methods
+
+```ruby
+# Check if US address is deliverable
+Truaddress::Client.deliverable?(result)  # DPV code = 'Y'
+
+# Check if US address is a mail drop (CMRA)
+Truaddress::Client.cmra?(result)
+
+# Check if US address is vacant
+Truaddress::Client.vacant?(result)
+
+# Check if international address is verified
+Truaddress::Client.verified?(result)
+
+# Format addresses as strings
+Truaddress::Client.format_us_address(result)    # "350 5th Ave, New York NY 10118"
+Truaddress::Client.format_intl_address(result)  # "10 Downing Street, London, SW1A 2AB"
+```
+
+## Error Handling
+
+```ruby
+begin
+  results = client.us_street(street: "123 Main St")
+rescue Truaddress::AuthenticationError => e
+  puts "Auth failed: #{e.message}"
+rescue Truaddress::ValidationError => e
+  puts "Invalid request: #{e.message}"
+rescue Truaddress::RateLimitError => e
+  puts "Rate limited: #{e.message}"
+rescue Truaddress::Error => e
+  puts "Error: #{e.message} (#{e.status_code})"
+end
+```
+
+## Rails Integration
+
+### Configuration (config/initializers/truaddress.rb)
+
+```ruby
+Truaddress.configure do |config|
+  config.api_key = Rails.application.credentials.truaddress_api_key
+end
+```
+
+### Controller Example
+
+```ruby
+class AddressesController < ApplicationController
+  def validate
+    results = Truaddress.client.us_street(
+      street: params[:street],
+      city: params[:city],
+      state: params[:state],
+      zipcode: params[:zipcode]
+    )
+
+    if results.any? && Truaddress::Client.deliverable?(results.first)
+      render json: { valid: true, address: results.first }
+    else
+      render json: { valid: false, message: "Address not deliverable" }
+    end
+  end
+end
+```
+
+### Model Validation
+
+```ruby
+class Order < ApplicationRecord
+  validate :validate_shipping_address
+
+  private
+
+  def validate_shipping_address
+    return if shipping_street.blank?
+
+    results = Truaddress.client.us_street(
+      street: shipping_street,
+      city: shipping_city,
+      state: shipping_state,
+      zipcode: shipping_zipcode
+    )
+
+    unless results.any? && Truaddress::Client.deliverable?(results.first)
+      errors.add(:shipping_address, "is not a valid deliverable address")
+    end
+  end
+end
+```
+
+### ActiveJob for Batch Processing
+
+```ruby
+class ValidateAddressesJob < ApplicationJob
+  def perform(customer_ids)
+    Customer.where(id: customer_ids).find_each do |customer|
+      results = Truaddress.client.us_street(
+        street: customer.street,
+        city: customer.city,
+        state: customer.state,
+        zipcode: customer.zipcode
+      )
+
+      customer.update(
+        address_valid: results.any? && Truaddress::Client.deliverable?(results.first),
+        address_validated_at: Time.current
+      )
+    end
+  end
+end
+```
+
+## Requirements
+
+- Ruby >= 2.7.0
+- faraday >= 1.0
+
+## License
+
+MIT

data/lib/truaddress/client.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Truaddress
+  # TruAddress API Client
+  #
+  # @example
+  #   client = Truaddress::Client.new(api_key: "YOUR_API_KEY")
+  #   results = client.us_street(street: "1600 Pennsylvania Ave NW", city: "Washington", state: "DC")
+  #
+  class Client
+    attr_reader :api_key, :base_url
+
+    # Initialize a new client
+    #
+    # @param api_key [String] Your TruAddress API key
+    # @param base_url [String] Base URL for the API (default: https://truaddress.net)
+    def initialize(api_key:, base_url: nil)
+      raise AuthenticationError, "API key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url || "https://truaddress.net"
+      @conn = build_connection
+    end
+
+    # ==========================================================================
+    # US Endpoints
+    # ==========================================================================
+
+    # Validate and standardize US street addresses
+    #
+    # @param street [String] Primary street address (required)
+    # @param street2 [String] Secondary address line
+    # @param secondary [String] Secondary designator (apt, suite, etc.)
+    # @param city [String] City name
+    # @param state [String] State abbreviation
+    # @param zipcode [String] ZIP code
+    # @param candidates [Integer] Maximum candidates to return (1-10)
+    # @param match [String] Match strategy ('strict', 'invalid', 'enhanced')
+    # @return [Array<Hash>] Validated address results
+    #
+    # @example
+    #   results = client.us_street(street: "350 5th Avenue", city: "New York", state: "NY")
+    #   puts results[0]["analysis"]["dpv_match_code"]  # => "Y"
+    #
+    def us_street(street:, street2: nil, secondary: nil, city: nil, state: nil, zipcode: nil, candidates: nil, match: nil)
+      get("/api/us-street", {
+        street: street,
+        street2: street2,
+        secondary: secondary,
+        city: city,
+        state: state,
+        zipcode: zipcode,
+        candidates: candidates,
+        match: match
+      })
+    end
+
+    # Look up city/state by ZIP code or find ZIP codes by city/state
+    #
+    # @param zipcode [String] 5-digit ZIP code
+    # @param city [String] City name
+    # @param state [String] State abbreviation
+    # @return [Array<Hash>] Results with city_states and zipcodes
+    #
+    # @example
+    #   result = client.us_zipcode(zipcode: "90210")
+    #   puts result[0]["city_states"][0]["city"]  # => "Beverly Hills"
+    #
+    def us_zipcode(zipcode: nil, city: nil, state: nil)
+      get("/api/us-zipcode", { zipcode: zipcode, city: city, state: state })
+    end
+
+    # Get address suggestions as user types
+    #
+    # @param search [String] Partial address to search
+    # @param selected [String] Previously selected suggestion
+    # @param max_results [Integer] Maximum suggestions to return
+    # @param city_filter [Array<String>] Cities to limit results to
+    # @param state_filter [Array<String>] States to limit results to
+    # @param zip_filter [Array<String>] ZIP codes to limit results to
+    # @return [Hash] Hash with 'suggestions' array
+    #
+    # @example
+    #   result = client.us_autocomplete(search: "350 5th Ave", state_filter: ["NY"])
+    #
+    def us_autocomplete(search:, selected: nil, max_results: nil, city_filter: nil, state_filter: nil, zip_filter: nil,
+                        prefer_cities: nil, prefer_states: nil, prefer_zips: nil, prefer_ratio: nil,
+                        prefer_geolocation: nil, source: nil)
+      get("/api/us-autocomplete", {
+        search: search,
+        selected: selected,
+        max_results: max_results,
+        city_filter: array_param(city_filter),
+        state_filter: array_param(state_filter),
+        zip_filter: array_param(zip_filter),
+        prefer_cities: array_param(prefer_cities),
+        prefer_states: array_param(prefer_states),
+        prefer_zips: array_param(prefer_zips),
+        prefer_ratio: prefer_ratio,
+        prefer_geolocation: prefer_geolocation,
+        source: source
+      })
+    end
+
+    # Extract addresses from unstructured text
+    #
+    # @param text [String] Text containing addresses
+    # @param aggressive [Boolean] Enable aggressive extraction mode
+    # @param addr_line_breaks [Boolean] Addresses span multiple lines
+    # @param addr_per_line [Integer] Max addresses per line
+    # @return [Hash] Hash with 'meta' and 'addresses' arrays
+    #
+    # @example
+    #   result = client.us_extract("Ship to 350 5th Ave, New York, NY 10118")
+    #
+    def us_extract(text, aggressive: nil, addr_line_breaks: nil, addr_per_line: nil)
+      post_text("/api/us-extract", text, {
+        aggressive: aggressive,
+        addr_line_breaks: addr_line_breaks,
+        addr_per_line: addr_per_line
+      })
+    end
+
+    # Get addresses near GPS coordinates
+    #
+    # @param latitude [Float] Latitude (-90 to 90)
+    # @param longitude [Float] Longitude (-180 to 180)
+    # @param source [String] Filter by type ('residential', 'commercial', 'all')
+    # @return [Hash] Hash with 'results' array of nearby addresses
+    #
+    # @example
+    #   result = client.us_reverse_geo(latitude: 40.748535, longitude: -73.9856571)
+    #
+    def us_reverse_geo(latitude:, longitude:, source: nil)
+      get("/api/us-reverse-geo", { latitude: latitude, longitude: longitude, source: source })
+    end
+
+    # ==========================================================================
+    # International Endpoints
+    # ==========================================================================
+
+    # Validate international addresses
+    #
+    # @param country [String] ISO-3 country code (e.g., 'GBR', 'FRA')
+    # @param freeform [String] Full address as single string
+    # @param address1 [String] Address line 1
+    # @param address2 [String] Address line 2
+    # @param address3 [String] Address line 3
+    # @param address4 [String] Address line 4
+    # @param locality [String] City/town
+    # @param administrative_area [String] State/province/region
+    # @param postal_code [String] Postal/ZIP code
+    # @param geocode [Boolean] Include coordinates
+    # @return [Array<Hash>] Validated address results
+    #
+    # @example
+    #   results = client.intl_street(country: "GBR", freeform: "10 Downing Street, London")
+    #
+    def intl_street(country:, freeform: nil, address1: nil, address2: nil, address3: nil, address4: nil,
+                    locality: nil, administrative_area: nil, postal_code: nil, geocode: nil)
+      get("/api/intl-street", {
+        country: country,
+        freeform: freeform,
+        address1: address1,
+        address2: address2,
+        address3: address3,
+        address4: address4,
+        locality: locality,
+        administrative_area: administrative_area,
+        postal_code: postal_code,
+        geocode: geocode
+      })
+    end
+
+    # Get international address suggestions
+    #
+    # @param search [String] Partial address to search
+    # @param country [String] ISO-3 country code
+    # @param max_results [Integer] Maximum suggestions to return
+    # @param distance [Integer] Search radius in meters
+    # @param latitude [Float] Latitude for location bias
+    # @param longitude [Float] Longitude for location bias
+    # @return [Hash] Hash with 'candidates' array
+    #
+    def intl_autocomplete(search:, country:, max_results: nil, distance: nil, latitude: nil, longitude: nil)
+      get("/api/intl-autocomplete", {
+        search: search,
+        country: country,
+        max_results: max_results,
+        distance: distance,
+        latitude: latitude,
+        longitude: longitude
+      })
+    end
+
+    # ==========================================================================
+    # Core Endpoints
+    # ==========================================================================
+
+    # Validate addresses worldwide
+    #
+    # @param address1 [String] Primary address line (required)
+    # @param country [String] Country code (ISO-2, ISO-3, or name)
+    # @param address2 [String] Secondary address line
+    # @param locality [String] City/town
+    # @param administrative_area [String] State/province
+    # @param postal_code [String] Postal/ZIP code
+    # @return [Array<Hash>] Validated address results
+    #
+    # @example
+    #   results = client.validate(
+    #     country: "US",
+    #     address1: "350 5th Avenue",
+    #     locality: "New York",
+    #     administrative_area: "NY"
+    #   )
+    #
+    def validate(address1:, country: nil, address2: nil, locality: nil, administrative_area: nil, postal_code: nil)
+      post("/api/validate", {
+        country: country,
+        address1: address1,
+        address2: address2,
+        locality: locality,
+        administrative_area: administrative_area,
+        postal_code: postal_code
+      })
+    end
+
+    # Correct and standardize addresses
+    #
+    # @param freeform [String] Full address as single string
+    # @param country [String] Country code
+    # @param address1 [String] Address line
+    # @param locality [String] City
+    # @param administrative_area [String] State/province
+    # @param postal_code [String] Postal/ZIP code
+    # @return [Array<Hash>] Corrected address results
+    #
+    # @example
+    #   results = client.correct(freeform: "1600 pennsylvania ave washington dc 20500")
+    #
+    def correct(freeform: nil, country: nil, address1: nil, locality: nil, administrative_area: nil, postal_code: nil)
+      post("/api/correct", {
+        freeform: freeform,
+        country: country,
+        address1: address1,
+        locality: locality,
+        administrative_area: administrative_area,
+        postal_code: postal_code
+      })
+    end
+
+    # Global address autocomplete
+    #
+    # @param q [String] Search query
+    # @param country [String] Filter by country code
+    # @param limit [Integer] Maximum suggestions
+    # @return [Hash] Hash with 'suggestions' array
+    #
+    def autocomplete(q:, country: nil, limit: nil)
+      get("/api/autocomplete", { q: q, country: country, limit: limit })
+    end
+
+    # ==========================================================================
+    # Helper Methods
+    # ==========================================================================
+
+    class << self
+      # Check if US address is deliverable (DPV match code = Y)
+      def deliverable?(result)
+        result.dig("analysis", "dpv_match_code") == "Y"
+      end
+
+      # Check if US address is a CMRA (Commercial Mail Receiving Agency)
+      def cmra?(result)
+        result.dig("analysis", "dpv_cmra") == "Y"
+      end
+
+      # Check if US address is vacant
+      def vacant?(result)
+        result.dig("analysis", "dpv_vacant") == "Y"
+      end
+
+      # Check if international address is verified
+      def verified?(result)
+        result.dig("analysis", "verification_status") == "Verified"
+      end
+
+      # Get formatted US address string
+      def format_us_address(result)
+        "#{result['delivery_line_1']}, #{result['last_line']}"
+      end
+
+      # Get formatted international address string
+      def format_intl_address(result)
+        [result["address1"], result["address2"], result["address3"], result["address4"]]
+          .compact
+          .reject(&:empty?)
+          .join(", ")
+      end
+    end
+
+    private
+
+    def build_connection
+      Faraday.new(url: base_url) do |f|
+        f.request :url_encoded
+        f.headers["X-API-Key"] = api_key
+        f.headers["User-Agent"] = "TruAddress-Ruby/#{VERSION}"
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def get(path, params = {})
+      response = @conn.get(path, compact_params(params))
+      handle_response(response)
+    end
+
+    def post(path, body = {})
+      response = @conn.post(path) do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate(compact_params(body))
+      end
+      handle_response(response)
+    end
+
+    def post_text(path, text, params = {})
+      query_string = URI.encode_www_form(compact_params(params))
+      full_path = query_string.empty? ? path : "#{path}?#{query_string}"
+      
+      response = @conn.post(full_path) do |req|
+        req.headers["Content-Type"] = "text/plain"
+        req.body = text
+      end
+      handle_response(response)
+    end
+
+    def handle_response(response)
+      body = JSON.parse(response.body)
+
+      case response.status
+      when 200..299
+        body
+      when 401
+        raise AuthenticationError.new(body["error"] || "Authentication failed", status_code: response.status)
+      when 400, 422
+        raise ValidationError.new(body["error"] || "Validation failed", status_code: response.status)
+      when 429
+        raise RateLimitError.new(body["error"] || "Rate limit exceeded", status_code: response.status)
+      when 500..599
+        raise ServerError.new(body["error"] || "Server error", status_code: response.status)
+      else
+        raise Error.new(body["error"] || "Unknown error", status_code: response.status)
+      end
+    rescue JSON::ParserError
+      raise Error.new("Invalid JSON response", status_code: response.status, response_body: response.body)
+    end
+
+    def compact_params(params)
+      params.reject { |_, v| v.nil? }
+    end
+
+    def array_param(value)
+      return nil if value.nil?
+      value.is_a?(Array) ? value.join(",") : value
+    end
+  end
+end

data/lib/truaddress/error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Truaddress
+  # Base error class for TruAddress errors
+  class Error < StandardError
+    attr_reader :status_code, :response_body
+
+    def initialize(message = nil, status_code: nil, response_body: nil)
+      @status_code = status_code
+      @response_body = response_body
+      super(message)
+    end
+  end
+
+  # Raised when API key is missing or invalid
+  class AuthenticationError < Error; end
+
+  # Raised when request parameters are invalid
+  class ValidationError < Error; end
+
+  # Raised when API rate limit is exceeded
+  class RateLimitError < Error; end
+
+  # Raised when API returns server error
+  class ServerError < Error; end
+end

data/lib/truaddress/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Truaddress
+  VERSION = "1.0.0"
+end

data/lib/truaddress.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "truaddress/version"
+require_relative "truaddress/error"
+require_relative "truaddress/client"
+
+# TruAddress Ruby SDK
+# Official SDK for address validation, autocomplete, and geocoding
+module Truaddress
+  class << self
+    attr_accessor :api_key, :base_url
+
+    def configure
+      yield self
+    end
+
+    def client
+      @client ||= Client.new(api_key: api_key, base_url: base_url)
+    end
+
+    # Reset the client (useful for testing)
+    def reset!
+      @client = nil
+    end
+  end
+
+  # Default base URL
+  self.base_url = "https://truaddress.net"
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: truaddress
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TruAddress
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-29 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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby SDK for TruAddress API. Validate, autocomplete, and geocode addresses
+  worldwide with USPS-grade accuracy.
+email:
+- support@truaddress.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/truaddress.rb
+- lib/truaddress/client.rb
+- lib/truaddress/error.rb
+- lib/truaddress/version.rb
+homepage: https://truaddress.net
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://truaddress.net
+  source_code_uri: https://github.com/truaddress/truaddress-ruby
+  documentation_uri: https://truaddress.net/docs
+  changelog_uri: https://github.com/truaddress/truaddress-ruby/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.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Official TruAddress SDK for Ruby - Address validation, autocomplete, and
+  geocoding
+test_files: []