fopost 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1845a9113bbfdb41688fd430794d43749707b835d82e2f0a4df826df43b4f1da
+  data.tar.gz: '08c64a3e1385d13789b22b5924f8672bcffbcf89dd524da03e8f3b94806fefc3'
+SHA512:
+  metadata.gz: d151dc7b437cfeb9e3369c3455f5534c8a2a599a17084eb5b6cc5ba77d5bc2d53ffdf887abba1eb33836e04b34d9d60b04f9b7958c9263e2882056137d07d1d9
+  data.tar.gz: 05f02730b6ab206ae44dbcaee5910253e10a28f8f6fd2eaa2f9f0d6ecae7c44e598716a4eff08e9f77565c528070dc9a8f68ea4075b59a7f5da93cf3af09487c

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this gem are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the gem follows
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-08-30
+
+Initial release.
+
+- `Fopost::Client` with `posts`, `accounts`, `workspaces`, `labels`, and `ai` resources.
+- Defaults to the documented `https://api.fopost.com/v1` base URL.
+- Automatic retry on `429`, honouring `Retry-After`.
+- Typed error classes per status, all rescuable as `Fopost::Error`.
+- Response models that accept either wire casing and keep unknown fields on `#raw`.
+- A pluggable transport, so the HTTP stack can be swapped or stubbed.
+
+[0.1.0]: https://github.com/fopost/fopost-ruby/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Porter Bridge, LLC
+
+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,250 @@
+# FoPost Ruby SDK
+
+[![Gem Version](https://img.shields.io/gem/v/fopost.svg)](https://rubygems.org/gems/fopost)
+[![Downloads](https://img.shields.io/gem/dt/fopost.svg)](https://rubygems.org/gems/fopost)
+[![CI](https://img.shields.io/github/actions/workflow/status/fopost/fopost-ruby/ci.yml?branch=main&label=ci)](https://github.com/fopost/fopost-ruby/actions)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+The official Ruby SDK for the [FoPost](https://fopost.com) API. Connect social accounts once, then compose, schedule, and publish to +30 platforms from your own application.
+
+Requires Ruby 3.1 or newer. No runtime dependencies: the gem talks over `net/http` from the standard library, so it drops into any app without a version conflict.
+
+> **0.x release.** The public API is still settling and minor versions may contain breaking changes. Pin an exact version if that matters to you.
+
+## Install
+
+```bash
+bundle add fopost
+```
+
+Or without Bundler:
+
+```bash
+gem install fopost
+```
+
+## Get an API key
+
+Create a key at [app.fopost.com/api-keys](https://app.fopost.com/api-keys). The full API reference lives at [fopost.com/docs](https://fopost.com/docs).
+
+## Quick start
+
+```ruby
+require 'fopost'
+
+client = Fopost.new(api_key: 'fp_...') # or set FOPOST_API_KEY
+
+workspace = client.workspaces.list.first
+accounts = client.accounts.list(workspace_id: workspace.id)
+
+post = client.posts.create(
+  workspace_id: workspace.id,
+  content: 'Hello from Ruby',
+  accounts: accounts.map(&:id)
+)
+
+client.posts.publish(post.id)
+```
+
+`content` takes a string for a single block, or an array for a thread:
+
+```ruby
+client.posts.create(
+  workspace_id: workspace.id,
+  content: [
+    'First post in the thread',
+    {
+      'text' => 'Second one, with an image',
+      'media' => [{ 'type' => 'image', 'name' => 'chart.png', 'url' => 'https://.../chart.png' }]
+    }
+  ],
+  accounts: accounts.map(&:id)
+)
+```
+
+`accounts` takes account ids, the `Fopost::SocialAccount` objects themselves, or hashes with an `id`.
+
+## Scheduling
+
+`status` is `"draft"` or `"scheduled"`; a scheduled post needs `schedule_at`. To send something out now, create it and call `publish`.
+
+```ruby
+client.posts.create(
+  workspace_id: workspace.id,
+  status: 'scheduled',
+  schedule_at: Time.utc(2026, 9, 1, 10, 0),
+  content: 'Scheduled with the SDK',
+  accounts: [accounts.first.id]
+)
+```
+
+`schedule_at` accepts a `Time`, a `DateTime`, or an ISO 8601 string.
+
+## Posts
+
+```ruby
+client.posts.get(post_id)
+client.posts.update(post_id, title: 'Renamed')  # partial: only what you pass is sent
+client.posts.delete(post_id)
+
+client.posts.publish(post_id)     # queue delivery to every targeted account
+client.posts.cancel(post_id)      # cancel what has not gone out yet
+client.posts.retry(post_id)       # retry only the deliveries that failed
+client.posts.preflight(post_id)   # per-account blockers, without publishing
+
+client.posts.deliveries(post_id).each { |d| puts "#{d.platform}: #{d.status}" }
+```
+
+`update` is a partial update, so passing `nil` clears a field and leaving an argument out leaves it alone:
+
+```ruby
+client.posts.update(post_id, schedule_at: nil)   # sends {"schedule_at": null}
+client.posts.update(post_id, title: 'Renamed')   # sends {"title": "Renamed"}
+```
+
+## Pagination
+
+`posts.list` returns one page, which is `Enumerable` over its items. `posts.each` walks every page for you.
+
+```ruby
+page = client.posts.list(workspace_id: workspace.id, status: 'published', per_page: 50)
+puts "#{page.meta.total} published posts"
+page.each { |post| puts "#{post.id} #{post.status}" }
+
+# Every post, one page fetched at a time
+client.posts.each(workspace_id: workspace.id) { |post| puts post.id }
+
+# Or page by page, when you want the meta
+client.posts.each_page(workspace_id: workspace.id) do |p|
+  puts "#{p.meta.current_page} (#{p.size} posts)"
+end
+```
+
+Both walkers return an `Enumerator` when called without a block, so `client.posts.each(...).lazy.first(10)` works.
+
+## AI features
+
+```ruby
+balance = client.ai.credits
+puts "#{balance.credits_remaining} of #{balance.credits_total} credits left"
+
+result = client.ai.generate_caption(
+  current_caption: 'shipping a new feature',
+  platforms: %w[twitter linkedin]
+)
+puts result.caption
+```
+
+`rewrite` and `repurpose_url` are wired the same way:
+
+```ruby
+rewrites = client.ai.rewrite(
+  content: 'Long article-style draft...',
+  platforms: %w[twitter linkedin bluesky]
+)
+rewrites.results.each { |variant| puts "#{variant.platform}: #{variant.content}" }
+
+repurposed = client.ai.repurpose_url(
+  url: 'https://example.com/blog/post',
+  platforms: %w[twitter linkedin bluesky threads]
+)
+```
+
+> **API keys reach `credits` and `generate_caption`.** `rewrite` and `repurpose_url` currently require a signed-in dashboard session and answer `401` to an API key. They are here so the surface is complete once the server opens them up.
+
+## Errors
+
+Every non-2xx response raises. All of them are rescuable as `Fopost::Error`.
+
+| Status  | Class                            |
+| ------- | -------------------------------- |
+| 400/422 | `Fopost::ValidationError`        |
+| 401     | `Fopost::AuthenticationError`    |
+| 402     | `Fopost::PaymentRequiredError`   |
+| 403     | `Fopost::PermissionDeniedError`  |
+| 404     | `Fopost::NotFoundError`          |
+| 429     | `Fopost::RateLimitError`         |
+| other   | `Fopost::Error`                  |
+
+```ruby
+begin
+  client.posts.publish(post_id)
+rescue Fopost::PaymentRequiredError => e
+  warn "Out of credits — upgrade at #{e.upgrade_url}"
+rescue Fopost::Error => e
+  warn "#{e.status} #{e.code}: #{e.message}"
+end
+```
+
+`message` is what the API said; `to_s` adds the status and code, so an uncaught error still reports both. `e.body` holds the decoded response, and `Fopost::ValidationError#errors` carries per-field messages when the API sends them.
+
+## Configuration
+
+```ruby
+Fopost.new(
+  api_key: 'fp_...',                            # or FOPOST_API_KEY
+  base_url: 'https://api.fopost.com/v1',    # override for a dev server
+  timeout: 30.0,                                # seconds
+  max_retries: 3,                               # total attempts on a 429
+  transport: MyTransport.new                    # bring your own HTTP stack
+)
+```
+
+| Env var          | Used for                                    |
+| ---------------- | ------------------------------------------- |
+| `FOPOST_API_KEY` | API key, when not passed to the constructor |
+
+A `429` is retried automatically, waiting for the interval the API asks for in `Retry-After` (delta-seconds or an HTTP date, capped at 60s). `max_retries` counts total attempts, so the default of 3 means two retries.
+
+## Endpoints the SDK does not wrap yet
+
+`client.request` reaches anything in the API, with the same auth, retries, and error handling:
+
+```ruby
+client.request(:get, '/analytics/overview', params: { 'workspace_id' => workspace.id })
+client.request(:post, '/webhooks', json: { 'url' => 'https://example.com/hook', 'events' => ['post.published'] })
+```
+
+## Swapping the HTTP stack
+
+The default transport is `net/http`. Anything that responds to `call(method:, url:, headers:, body:)` and returns a `Fopost::HTTP::Response` can replace it — useful for a shared connection pool, custom instrumentation, or stubbing the network in tests.
+
+```ruby
+class LoggingTransport
+  include Fopost::HTTP::Transport
+
+  def initialize(inner) = @inner = inner
+
+  def call(method:, url:, headers:, body:)
+    warn "#{method} #{url}"
+    @inner.call(method: method, url: url, headers: headers, body: body)
+  end
+end
+
+client = Fopost.new(transport: LoggingTransport.new(Fopost::HTTP::NetHTTPTransport.new))
+```
+
+## Models
+
+Responses come back as small model objects with snake_case readers. The API is not consistent about its wire casing — posts come back snake_case, accounts camelCase — so both spellings parse. Fields the SDK does not model yet stay reachable:
+
+```ruby
+post.raw['someNewField']  # the decoded body, exactly as sent
+post['some_new_field']    # by either spelling
+```
+
+That means a field added server-side never breaks an older client.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test
+bundle exec rubocop
+```
+
+Tests run against a stubbed transport, so nothing touches the network.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/fopost/client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'fopost/http/client'
+require 'fopost/models'
+require 'fopost/resources/base'
+require 'fopost/resources/accounts'
+require 'fopost/resources/ai'
+require 'fopost/resources/labels'
+require 'fopost/resources/posts'
+require 'fopost/resources/workspaces'
+
+module Fopost
+  # Client for the FoPost API.
+  #
+  #   client = Fopost::Client.new(api_key: 'fp_...')
+  #   accounts = client.accounts.list(workspace_id: '9b2f6c1e-...')
+  #
+  # The key falls back to the `FOPOST_API_KEY` environment variable. Requests
+  # that come back 429 are retried up to `max_retries` attempts, waiting for the
+  # interval the API asks for in `Retry-After`.
+  class Client
+    DEFAULT_BASE_URL = HTTP::Client::DEFAULT_BASE_URL
+
+    attr_reader :posts, :accounts, :workspaces, :labels, :ai
+
+    def initialize(api_key: nil, base_url: DEFAULT_BASE_URL, timeout: HTTP::Client::DEFAULT_TIMEOUT,
+                   max_retries: HTTP::Client::DEFAULT_MAX_RETRIES, transport: nil, sleeper: nil)
+      key = api_key || ENV['FOPOST_API_KEY']
+      if key.nil? || key.to_s.empty?
+        raise ConfigurationError,
+              'fopost: an api key is required — pass api_key: or set FOPOST_API_KEY'
+      end
+
+      @http = HTTP::Client.new(
+        api_key: key,
+        base_url: base_url,
+        timeout: timeout,
+        max_retries: max_retries,
+        transport: transport,
+        sleeper: sleeper
+      )
+
+      @posts = Resources::Posts.new(@http)
+      @accounts = Resources::Accounts.new(@http)
+      @workspaces = Resources::Workspaces.new(@http)
+      @labels = Resources::Labels.new(@http)
+      @ai = Resources::Ai.new(@http)
+    end
+
+    def base_url
+      @http.base_url
+    end
+
+    # Call an endpoint the SDK does not wrap yet. Returns the decoded body.
+    def request(method, path, json: nil, params: nil)
+      @http.request(method, path, json: json, params: params)
+    end
+
+    def inspect
+      "#<Fopost::Client base_url=#{base_url.inspect}>"
+    end
+  end
+end

data/lib/fopost/errors.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Fopost
+  # Base class for every error the FoPost API returns.
+  #
+  # The API answers failures with an `{"error": "<code>", "message": "<human
+  # readable>"}` envelope, which maps onto {#code} and {#message}.
+  class Error < StandardError
+    attr_reader :status, :code, :body
+
+    # The message the API sent, undecorated. `to_s` adds the status and code,
+    # so an uncaught error still reports both.
+    attr_reader :message
+
+    def initialize(message, status:, code: nil, body: nil)
+      super(message)
+      @message = message
+      @status = status
+      @code = code
+      @body = body
+    end
+
+    def to_s
+      suffix = code ? " (#{code})" : ''
+      "[#{status}#{suffix}] #{@message}"
+    end
+  end
+
+  # Raised before a request goes out, when the client is misconfigured.
+  class ConfigurationError < StandardError; end
+
+  # 400 or 422 — the request body did not pass validation.
+  class ValidationError < Error
+    # Per-field messages, when the API sends them.
+    def errors
+      value = body.is_a?(Hash) ? (body['errors'] || body[:errors]) : nil
+      value.is_a?(Hash) || value.is_a?(Array) ? value : nil
+    end
+  end
+
+  # 401 — missing, invalid, or expired API key.
+  class AuthenticationError < Error; end
+
+  # 402 — no active subscription, or AI credits exhausted.
+  class PaymentRequiredError < Error
+    # The page the API suggests sending the user to.
+    def upgrade_url
+      value = body.is_a?(Hash) ? (body['upgrade_url'] || body[:upgrade_url]) : nil
+      value.is_a?(String) ? value : nil
+    end
+  end
+
+  # 403 — the key is valid but lacks the scope or the workspace.
+  class PermissionDeniedError < Error; end
+
+  # 404 — no such resource, or it is outside the key's reach.
+  class NotFoundError < Error; end
+
+  # 429 — rate limit exceeded. {#retry_after} is in seconds when the API sends it.
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message, status:, code: nil, body: nil, retry_after: nil)
+      super(message, status: status, code: code, body: body)
+      @retry_after = retry_after
+    end
+  end
+
+  # Maps an HTTP status plus a decoded body onto the most specific error class.
+  module ErrorFactory
+    BY_STATUS = {
+      400 => ValidationError,
+      401 => AuthenticationError,
+      402 => PaymentRequiredError,
+      403 => PermissionDeniedError,
+      404 => NotFoundError,
+      422 => ValidationError,
+      429 => RateLimitError
+    }.freeze
+
+    def self.build(status, body, retry_after: nil)
+      code = nil
+      message = "HTTP #{status}"
+
+      if body.is_a?(Hash)
+        code = body['error'] if body['error'].is_a?(String)
+        if body['message'].is_a?(String) && !body['message'].empty?
+          message = body['message']
+        elsif code
+          message = code
+        end
+      elsif body.is_a?(String) && !body.strip.empty?
+        message = body.strip
+      end
+
+      klass = BY_STATUS.fetch(status, Error)
+      if klass == RateLimitError
+        return RateLimitError.new(message, status: status, code: code, body: body,
+                                           retry_after: retry_after)
+      end
+
+      klass.new(message, status: status, code: code, body: body)
+    end
+  end
+end

data/lib/fopost/http/client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require 'uri'
+
+require 'fopost/errors'
+require 'fopost/version'
+require 'fopost/http/net_http_transport'
+
+module Fopost
+  module HTTP
+    # Internal transport wrapper: auth headers, JSON coding, envelope unwrap,
+    # and the 429 retry. One per {Fopost::Client}.
+    class Client
+      DEFAULT_BASE_URL = 'https://api.fopost.com/v1'
+      DEFAULT_TIMEOUT = 30.0
+      DEFAULT_MAX_RETRIES = 3
+      MAX_RETRY_WAIT = 60.0
+
+      USER_AGENT = "fopost-ruby/#{Fopost::VERSION}".freeze
+
+      attr_reader :base_url, :max_retries
+
+      def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT,
+                     max_retries: DEFAULT_MAX_RETRIES, transport: nil, sleeper: nil)
+        raise ConfigurationError, 'fopost: api_key is required' if api_key.nil? || api_key.to_s.empty?
+        raise ConfigurationError, 'fopost: max_retries must be at least 1' if max_retries < 1
+
+        @api_key = api_key
+        @base_url = base_url.to_s.sub(%r{/+\z}, '')
+        @max_retries = max_retries
+        @transport = transport || NetHTTPTransport.new(timeout: timeout)
+        # Indirected so tests can replace the wait without touching the real clock.
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      end
+
+      def headers
+        {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json',
+          'X-API-Key' => @api_key,
+          'User-Agent' => USER_AGENT
+        }
+      end
+
+      # Send a request, retrying on 429, and return the decoded body.
+      def request(method, path, json: nil, params: nil)
+        url = build_url(path, params)
+        body = json.nil? ? nil : JSON.generate(json)
+
+        attempt = 0
+        loop do
+          attempt += 1
+          response = @transport.call(method: method.to_s.upcase, url: url, headers: headers, body: body)
+
+          if response.status == 429 && attempt < @max_retries
+            wait = retry_after_seconds(response)
+            @sleeper.call([wait || 1.0, MAX_RETRY_WAIT].min)
+            next
+          end
+
+          return decode(response)
+        end
+      end
+
+      def get(path, params = nil)
+        request(:get, path, params: params)
+      end
+
+      def post(path, json = nil)
+        request(:post, path, json: json)
+      end
+
+      def put(path, json = nil)
+        request(:put, path, json: json)
+      end
+
+      def delete(path, json = nil)
+        request(:delete, path, json: json)
+      end
+
+      # Peel the `{"data": ...}` envelope the API wraps most responses in. Some
+      # endpoints (POST /posts, GET /posts/:id) return the resource bare, so the
+      # envelope comes off only when it is actually there.
+      def self.unwrap(body)
+        body.is_a?(Hash) && body.key?('data') ? body['data'] : body
+      end
+
+      private
+
+      def build_url(path, params)
+        uri = URI.parse(path.to_s)
+        uri = URI.parse("#{@base_url}/#{path.to_s.sub(%r{\A/+}, '')}") if uri.scheme.nil?
+
+        query = (params || {}).compact
+        unless query.empty?
+          existing = uri.query.to_s
+          encoded = URI.encode_www_form(query.map { |k, v| [k.to_s, v.to_s] })
+          uri.query = existing.empty? ? encoded : "#{existing}&#{encoded}"
+        end
+        uri
+      end
+
+      def decode(response)
+        body = decode_body(response)
+
+        if response.success?
+          if body.is_a?(String)
+            content_type = response.header('content-type')
+            raise Error.new(
+              "Expected a JSON response, got #{content_type || 'no content type'}",
+              status: response.status,
+              body: body
+            )
+          end
+          return body
+        end
+
+        raise ErrorFactory.build(response.status, body, retry_after: retry_after_seconds(response))
+      end
+
+      def decode_body(response)
+        return nil if response.status == 204 || response.body.nil? || response.body.empty?
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        response.body
+      end
+
+      # Retry-After is either delta-seconds or an HTTP date.
+      def retry_after_seconds(response)
+        raw = response.header('retry-after')
+        return nil if raw.nil?
+
+        raw = raw.to_s.strip
+        return nil if raw.empty?
+
+        seconds = Float(raw, exception: false)
+        return [0.0, seconds].max if seconds
+
+        target = Time.httpdate(raw) rescue (Time.parse(raw) rescue nil)
+        return nil unless target
+
+        [0.0, target.to_f - Time.now.to_f].max
+      end
+    end
+  end
+end

data/lib/fopost/http/net_http_transport.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'fopost/http/response'
+require 'fopost/http/transport'
+
+module Fopost
+  module HTTP
+    # The default transport: Ruby's own net/http, so the gem needs no
+    # dependency of its own.
+    class NetHTTPTransport
+      include Transport
+
+      METHODS = {
+        'GET' => Net::HTTP::Get,
+        'POST' => Net::HTTP::Post,
+        'PUT' => Net::HTTP::Put,
+        'PATCH' => Net::HTTP::Patch,
+        'DELETE' => Net::HTTP::Delete
+      }.freeze
+
+      def initialize(timeout: 30.0, open_timeout: nil)
+        @timeout = timeout
+        @open_timeout = open_timeout || timeout
+      end
+
+      def call(method:, url:, headers:, body:)
+        uri = url.is_a?(URI) ? url : URI.parse(url)
+        klass = METHODS.fetch(method.to_s.upcase) do
+          raise ArgumentError, "fopost: unsupported HTTP method #{method}"
+        end
+
+        request = klass.new(uri)
+        headers.each { |name, value| request[name] = value }
+        request.body = body if body
+
+        response = http_for(uri).request(request)
+        Response.new(status: response.code.to_i, body: response.body || '',
+                     headers: response.to_hash.transform_values(&:first))
+      end
+
+      private
+
+      def http_for(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = @timeout
+        http.write_timeout = @timeout if http.respond_to?(:write_timeout=)
+        http.open_timeout = @open_timeout
+        http
+      end
+    end
+  end
+end

data/lib/fopost/http/response.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Fopost
+  module HTTP
+    # What a {Transport} hands back: the raw status, headers, and body.
+    class Response
+      attr_reader :status, :headers, :body
+
+      def initialize(status:, body: '', headers: {})
+        @status = status
+        @body = body.to_s
+        @headers = headers.each_with_object({}) { |(k, v), out| out[k.to_s.downcase] = v }
+      end
+
+      def success?
+        status >= 200 && status < 300
+      end
+
+      def header(name)
+        headers[name.to_s.downcase]
+      end
+    end
+  end
+end