nb_api_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2082f32bdb205caf63485893abe3199b480329fde2079592e38ba4b53b37660d
+  data.tar.gz: 793459a2c5f1271be72812d91cbf8d251795c8dffa5d73edb4d0d68047ca62e8
+SHA512:
+  metadata.gz: efd0d26a0b2ac02fa0cd418b0ff27281fea5afa8122790d0ef36b83dc81216604d0395576b01207d4321de2cc39a446d03ee1b988ed1f5d18b85f79bbc5b26c2
+  data.tar.gz: d19ea9e67bb1689876e9d33d81c561ae452b59f41a5c736df151c4c7d90ef34a185a6b6c0602e1fcbfe496faf0fc90f15941fa99f4207c44112cf5c36c8cc3a8

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.1] - 2026-07-16
+
+- Publish to rubygems.org instead of GitLab's RubyGems registry (which is
+  feature-flagged off on this project) and fix `allowed_push_host`/CI
+  publish setup accordingly.
+
+## [0.1.0] - 2026-07-16
+
+- Initial release: `NbApiClient::Request` (rate-limited, token-refreshing HTTP
+  calls) and `NbApiClient::RateLimiter` (Redis-backed sliding-window rate
+  limiter).

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Flint
+
+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,112 @@
+# NbApiClient
+
+A rate-limited, token-refreshing HTTP client for the NationBuilder API, for use in Rails apps that integrate with NationBuilder on behalf of many OAuth-connected accounts ("nations").
+
+It provides two pieces:
+
+- `NbApiClient::Request` — makes a single authenticated API call, transparently retrying on rate limits and refreshing expired OAuth tokens.
+- `NbApiClient::RateLimiter` — a Redis-backed sliding-window rate limiter shared across every process/thread in your fleet, so you don't blow through NationBuilder's server-side rate limit when running many workers.
+
+## Installation
+
+This gem is published to [rubygems.org](https://rubygems.org/gems/nb_api_client). Add to your Gemfile:
+
+```ruby
+gem "nb_api_client"
+```
+
+If you're working against an unreleased checkout instead, a path source still works:
+
+```ruby
+gem "nb_api_client", path: "gems/nb_api_client"
+```
+
+## Usage
+
+```ruby
+NbApiClient::Request.call(nation, :get, "/api/v2/people/123")
+NbApiClient::Request.call(nation, :post, "/api/v2/people", {person: {email: "a@b.com"}})
+```
+
+### The `nation` interface
+
+`nation` can be any object — it does not need to be an ActiveRecord model — that responds to:
+
+| Method | Returns |
+| --- | --- |
+| `slug` | A string uniquely identifying the account (used as a cache-key/log prefix). |
+| `active?` | Whether requests should be allowed (checked before every call, except `/oauth/token`). |
+| `url` | The base URL for the account, e.g. `"https://myorg.nationbuilder.com"`. |
+| `token` | The current OAuth access token, appended as a query param on every request. |
+| `refresh_oauth_token` | Refreshes the OAuth token in place; returns truthy on success, falsy on failure. |
+| `deauthorize` | Called after too many consecutive "unauthorized" responses (see `unauthorized_error_threshold` below). |
+
+### Configuration
+
+```ruby
+NbApiClient.configure do |config|
+  # Called after `nation.deauthorize` when a nation has failed authorization
+  # too many times in a row. Use this to notify the account owner or schedule
+  # a job that retries the OAuth flow later.
+  config.on_repeated_unauthorized = ->(nation) {
+    ReauthorizeNationJob.set(queue: nation.sidekiq_queue).perform_in(1.hour, nation.id)
+  }
+
+  # How many "unauthorized" responses within `unauthorized_error_window`
+  # seconds before a nation is deauthorized. Defaults: 25 within 300s.
+  config.unauthorized_error_threshold = 25
+  config.unauthorized_error_window = 5 * 60
+
+  # Cache store used to count those unauthorized responses. Defaults to
+  # Rails.cache; must respond to #increment(key, amount, options).
+  config.cache_store = Rails.cache
+
+  # Logger for rate-limit/retry warnings. Defaults to Rails.logger.
+  config.logger = Rails.logger
+
+  # If true (the default), Request.call short-circuits to `{}` under
+  # Rails.env.test? instead of making a real HTTP call. Set to false if you'd
+  # rather stub HTTP at a lower level (e.g. WebMock/VCR) in your test suite.
+  config.short_circuit_in_test = true
+
+  # Sliding-window rate limit enforced via Redis across every process.
+  config.rate_limit = 200               # requests
+  config.rate_limit_window_seconds = 10 # per this many seconds
+  config.rate_limit_max_wait_seconds = 120
+  config.rate_limit_pool_size = 6        # Redis connection pool size
+  config.redis_url = ENV.fetch("REDIS_URL", "redis://localhost:6379/0")
+end
+```
+
+All of the above have working defaults (matching NationBuilder's published limits with a safety margin), so a new app can start with zero configuration beyond `on_repeated_unauthorized`.
+
+### Error handling
+
+`NbApiClient::Request.call` raises:
+
+- `NbApiClient::Request::UnauthorizedNationError` — the nation is inactive, or has been deauthorized after repeated auth failures.
+- `NbApiClient::Request::RateLimitedError` — NationBuilder returned 429 more than `max_rate_limit_retries` times in a row.
+- `NbApiClient::Request::InvalidContentType` — the API returned a non-JSON error body.
+- `NbApiClient::RateLimiter::RateLimitExhausted` — the local rate limiter couldn't get a slot within `rate_limit_max_wait_seconds`.
+- `OAuth2::Error` — token refresh failed, or the API returned an unrecognized JSON error.
+
+These are ordinary Ruby exception classes, so they compose naturally with e.g. Sidekiq's `sidekiq_retry_in`/`sidekiq_retries_exhausted` hooks.
+
+## Running the gem's own tests
+
+```
+bundle install
+bundle exec rake test
+```
+
+The two Lua-script integration tests in `rate_limiter_test.rb` are skipped automatically if no Redis is reachable at `REDIS_URL`.
+
+## Releasing a new version
+
+1. Bump `NbApiClient::VERSION` in `lib/nb_api_client/version.rb` and add an entry to `CHANGELOG.md`.
+2. Commit, then tag the commit `vX.Y.Z` and push the tag.
+3. In the resulting GitLab pipeline, manually run the `publish` job (it refuses to run unless the tag matches the gem version). This requires a protected, masked `GEM_HOST_API_KEY` CI/CD variable holding a [rubygems.org API key](https://guides.rubygems.org/publishing/#publishing-your-gem) scoped to "push rubygem" for this gem.
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt).

data/lib/nb_api_client/configuration.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module NbApiClient
+  class Configuration
+    # Cache store used to count repeated "unauthorized" responses for a nation.
+    # Must respond to #increment(key, amount, options) and #exist?/#write (if you
+    # also use the cache in on_repeated_unauthorized). Defaults to Rails.cache.
+    attr_accessor :cache_store
+
+    # Logger for rate-limit and retry warnings. Defaults to Rails.logger.
+    attr_accessor :logger
+
+    # Called with the nation whenever it has been deauthorized after too many
+    # consecutive "unauthorized" API responses. Use this to schedule re-authorization
+    # (e.g. a background job) or notify the account owner. Optional.
+    attr_accessor :on_repeated_unauthorized
+
+    # How many "unauthorized" responses within unauthorized_error_window before a
+    # nation is deauthorized.
+    attr_accessor :unauthorized_error_threshold
+
+    # Rolling window, in seconds, over which unauthorized_error_threshold is counted.
+    attr_accessor :unauthorized_error_window
+
+    # If true (the default), NbApiClient::Request#call returns {} immediately in
+    # Rails.env.test? instead of making a real HTTP request. This only applies when
+    # Request.call is invoked directly (not when it has been stubbed out in tests).
+    attr_accessor :short_circuit_in_test
+
+    attr_accessor :max_rate_limit_retries
+    attr_accessor :max_token_retries
+
+    # Sliding-window rate limit: at most `rate_limit` requests per `rate_limit_window_seconds`,
+    # enforced across all processes via Redis.
+    attr_accessor :rate_limit
+    attr_accessor :rate_limit_window_seconds
+    attr_accessor :rate_limit_max_wait_seconds
+    attr_accessor :rate_limit_poll_interval
+    attr_accessor :rate_limit_max_jitter
+    attr_accessor :rate_limit_pool_size
+    attr_accessor :redis_url
+
+    def initialize
+      @cache_store = (defined?(Rails) && Rails.respond_to?(:cache)) ? Rails.cache : nil
+      @logger = (defined?(Rails) && Rails.respond_to?(:logger)) ? Rails.logger : nil
+      @on_repeated_unauthorized = nil
+      @unauthorized_error_threshold = 25
+      @unauthorized_error_window = 5 * 60
+      @short_circuit_in_test = true
+      @max_rate_limit_retries = 3
+      @max_token_retries = 2
+
+      @rate_limit = ENV.fetch("API_RATE_LIMIT", 200).to_i
+      @rate_limit_window_seconds = ENV.fetch("API_RATE_WINDOW", 10).to_i
+      @rate_limit_max_wait_seconds = ENV.fetch("API_RATE_MAX_WAIT_SECONDS", 120).to_i
+      @rate_limit_poll_interval = 0.25
+      @rate_limit_max_jitter = 0.25
+      @rate_limit_pool_size = ENV.fetch("RATE_LIMITER_POOL_SIZE", 6).to_i
+      @redis_url = ENV.fetch("REDIS_URL", "redis://localhost:6379/0")
+    end
+  end
+end

data/lib/nb_api_client/rate_limiter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module NbApiClient
+  # A global (cross-process, cross-thread) distributed rate limiter backed by Redis.
+  # Implements a sliding-window algorithm in a Lua script (atomic ZADD/ZREMRANGEBYSCORE/ZCARD
+  # on a sorted set) to enforce "N requests per window" across every process sharing the
+  # same Redis. All callers share one window (configure via NbApiClient.configure).
+  class RateLimiter
+    class RateLimitExhausted < StandardError; end
+
+    # 1. Remove all entries older than (now - window) to slide the window
+    # 2. Count remaining entries in the set
+    # 3. If under the limit, add a new entry (scored by timestamp) and return the new count
+    # 4. If at/over the limit, return -1 (rejected)
+    #
+    # The sorted set key is given a TTL of 2*window as a safety net to avoid
+    # unbounded memory growth if traffic stops entirely.
+    ACQUIRE_SLOT_SCRIPT = <<~LUA
+      local key = KEYS[1]
+      local limit = tonumber(ARGV[1])
+      local window = tonumber(ARGV[2])
+      local now = tonumber(ARGV[3])
+      local member = ARGV[4]
+
+      -- Prune entries outside the sliding window
+      redis.call('ZREMRANGEBYSCORE', key, '-inf', now - window)
+
+      local count = redis.call('ZCARD', key)
+
+      if count < limit then
+        redis.call('ZADD', key, now, member)
+        -- Safety-net expiry so the key doesn't live forever if traffic stops
+        redis.call('EXPIRE', key, window * 2)
+        return count + 1
+      else
+        return -1
+      end
+    LUA
+
+    # Blocks until a request slot is available, then yields to the caller.
+    # Raises RateLimitExhausted if the wait exceeds configuration.rate_limit_max_wait_seconds.
+    def self.with_limit(&block)
+      new.with_limit(&block)
+    end
+
+    def initialize
+      @key = "nb_rate_limit:window"
+    end
+
+    def with_limit
+      config = NbApiClient.configuration
+      waited = 0.0
+
+      loop do
+        result = try_acquire_slot
+        if result > 0
+          return yield
+        else
+          if waited >= config.rate_limit_max_wait_seconds
+            raise RateLimitExhausted, "Rate limit exhausted after waiting #{waited}s"
+          end
+
+          # Sleep with jitter to spread retries and avoid thundering herd
+          sleep_time = config.rate_limit_poll_interval + rand(0.0..config.rate_limit_max_jitter)
+          sleep(sleep_time)
+          waited += sleep_time
+        end
+      end
+    rescue ConnectionPool::TimeoutError, Redis::BaseError, RedisClient::Error => e
+      # Fail open: if Redis is unavailable, allow the request through.
+      # NbApiClient::Request's 429 handling acts as a safety net.
+      config.logger&.warn("[NbApiClient::RateLimiter] Redis error, failing open: #{e.class} - #{e.message}")
+      yield
+    end
+
+    private
+
+    # Attempts to acquire a slot in the sliding window.
+    # Returns the new count (positive) on success, or -1 if the window is full.
+    def try_acquire_slot
+      config = NbApiClient.configuration
+      now = Process.clock_gettime(Process::CLOCK_REALTIME)
+      member = "#{now}:#{SecureRandom.hex(4)}"
+
+      redis do |conn|
+        conn.eval(
+          ACQUIRE_SLOT_SCRIPT,
+          keys: [@key],
+          argv: [config.rate_limit.to_s, config.rate_limit_window_seconds.to_s, now.to_s, member]
+        )
+      end
+    end
+
+    def redis(&block)
+      NbApiClient.connection_pool.with(&block)
+    end
+  end
+end

data/lib/nb_api_client/request.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module NbApiClient
+  # Makes an authenticated request against the NationBuilder API on behalf of a
+  # "nation" (any object satisfying the interface documented in the gem README),
+  # handling rate limiting, OAuth token refresh, and repeated-authorization-failure
+  # deauthorization.
+  class Request
+    class UnauthorizedNationError < StandardError
+      attr_reader :nation
+
+      def initialize(nation:)
+        @nation = nation
+        super("Unauthorized nation: #{nation}")
+      end
+    end
+
+    class RateLimitedError < StandardError
+      attr_reader :retry_after
+
+      def initialize(retry_after:)
+        @retry_after = retry_after
+        super("Rate limited, retry after #{retry_after}s")
+      end
+    end
+
+    class InvalidContentType < StandardError
+      def initialize(nation:, body:, content_type:)
+        super("Invalid response content type (#{content_type}) for #{nation}: #{body}")
+      end
+    end
+
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(nation, action, path, body = {})
+      @nation = nation
+      @action = action
+      @path = path
+      @url = UrlBuilder.new(@nation, @path).url
+      @body = body.is_a?(Hash) ? body.to_json : body
+    end
+
+    def call
+      config = NbApiClient.configuration
+      return {} if config.short_circuit_in_test && defined?(Rails) && Rails.respond_to?(:env) && Rails.env.test?
+      raise UnauthorizedNationError.new(nation: @nation.slug) unless @nation.active? || @path == "/oauth/token"
+
+      options = {timeout: 30, uri_adapter: Addressable::URI}
+      rate_limit_retries = 0
+      token_retries = 0
+
+      loop do
+        @response = RateLimiter.with_limit do
+          HTTParty.send(
+            @action,
+            @url,
+            body: @body,
+            headers: {Accept: "application/json", "Content-type": "application/json"},
+            **options
+          )
+        end
+
+        return @response if @response.success?
+
+        if rate_limit_error?
+          wait_seconds = @response.headers["retry-after"].to_i + 1
+          config.logger&.warn("[NbApiClient::Request] Rate limited: #{@action.upcase} #{@path} nation=#{@nation.slug} retry_after=#{wait_seconds}s rate_limit_retries=#{rate_limit_retries}")
+
+          raise RateLimitedError.new(retry_after: wait_seconds) if (rate_limit_retries += 1) > config.max_rate_limit_retries
+
+          sleep wait_seconds
+          next
+        elsif expired_token_error?
+          raise OAuth2::Error.new(@response) if (token_retries += 1) > config.max_token_retries
+          raise OAuth2::Error.new(@response) unless @nation.refresh_oauth_token
+
+          next
+        elsif unauthorized_error?
+          raise OAuth2::Error.new(@response) if (token_retries += 1) > config.max_token_retries
+
+          if too_many_unauthorized_errors?(config)
+            @nation.deauthorize
+            config.on_repeated_unauthorized&.call(@nation)
+            raise UnauthorizedNationError.new(nation: @nation.slug)
+          end
+
+          @nation.refresh_oauth_token
+          next
+        elsif @response.content_type.in?(["application/json", "application/vnd.api+json"])
+          raise OAuth2::Error.new(@response)
+        else
+          raise InvalidContentType.new(nation: @nation.slug, body: @response.body, content_type: @response.content_type)
+        end
+      end
+    end
+
+    private
+
+    def too_many_unauthorized_errors?(config)
+      config.cache_store.increment("#{@nation.slug}_nb_unauthorized_errors", 1, expires_in: config.unauthorized_error_window) > config.unauthorized_error_threshold
+    end
+
+    def rate_limit_error?
+      @response.code == 429 && @response.headers["retry-after"].present?
+    end
+
+    def unauthorized_error?
+      @response.fetch("code", "") == "unauthorized"
+    end
+
+    def expired_token_error?
+      ["token_expired", "invalid_grant"].include?(@response.fetch("code", ""))
+    end
+  end
+end

data/lib/nb_api_client/url_builder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NbApiClient
+  # Builds a fully-qualified NationBuilder API URL for a given nation and path,
+  # appending the nation's OAuth access token as a query parameter (unless the
+  # path is an OAuth endpoint, which is unauthenticated).
+  class UrlBuilder
+    def initialize(nation, path)
+      @nation = nation
+      @path = path
+
+      raise ArgumentError, "Path cannot be empty" if @path.blank?
+    end
+
+    def url
+      url_string = @path.start_with?("http") ? @path : @nation.url + @path
+
+      uri = URI.parse(url_string)
+      new_query_ar = if @path.start_with?("/oauth/")
+        URI.decode_www_form(String(uri.query))
+      else
+        URI.decode_www_form(String(uri.query)) << ["access_token", @nation.token]
+      end
+      uri.query = URI.encode_www_form(new_query_ar)
+
+      uri.to_s
+    end
+  end
+end

data/lib/nb_api_client/version.rb

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

data/lib/nb_api_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "securerandom"
+
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/inclusion"
+
+require "httparty"
+require "addressable/uri"
+require "oauth2"
+require "redis"
+require "connection_pool"
+
+require_relative "nb_api_client/version"
+require_relative "nb_api_client/configuration"
+require_relative "nb_api_client/url_builder"
+require_relative "nb_api_client/rate_limiter"
+require_relative "nb_api_client/request"
+
+module NbApiClient
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    # Lazily built so it always reflects the redis_url/pool_size in effect the
+    # first time a request needs it (i.e. after any NbApiClient.configure block
+    # has run).
+    def connection_pool
+      @connection_pool ||= ConnectionPool.new(size: configuration.rate_limit_pool_size, timeout: 3) {
+        Redis.new(url: configuration.redis_url)
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: nb_api_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Flint
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Wraps NationBuilder API requests with OAuth token refresh, deauthorization
+  handling, and a Redis-backed sliding-window rate limiter shared across processes.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/nb_api_client.rb
+- lib/nb_api_client/configuration.rb
+- lib/nb_api_client/rate_limiter.rb
+- lib/nb_api_client/request.rb
+- lib/nb_api_client/url_builder.rb
+- lib/nb_api_client/version.rb
+homepage: https://gitlab.com/acflint/nb_api_client
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://gitlab.com/acflint/nb_api_client
+  changelog_uri: https://gitlab.com/acflint/nb_api_client/-/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: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Rate-limited, token-refreshing HTTP client for the NationBuilder API
+test_files: []