equipoise 0.1.0

data/lib/equipoise/configuration.rb

@@ -0,0 +1,136 @@
+# =============================================================================
+# Equipoise::Configuration
+# =============================================================================
+#
+# Holds the producer's connection settings. api_key, base_url, and source are
+# read from the environment LAZILY (on every read) unless explicitly assigned:
+#
+#   EQUIPOISE_API_KEY  → api_key   (eq_live_… / eq_test_…)
+#   EQUIPOISE_API_URL  → base_url  (defaults to the production host)
+#   EQUIPOISE_SOURCE   → source    (the producer's source identifier)
+#
+# Reading from ENV at call time is what makes the key rotation-aware: rotate the
+# secret in the environment and the next request picks it up — no redeploy. An
+# explicit `config.api_key = "…"` captures the value and is NOT rotation-aware.
+#
+# Transport security: `validate!` refuses to send credentials over plaintext
+# HTTP to a non-loopback host (an `http://` base_url would leak the Bearer key on
+# the wire). Local dev (`http://localhost`) is allowed; set `allow_insecure_http`
+# to permit a trusted TLS-terminating internal endpoint.
+#
+# Used by: Equipoise.configure, Equipoise::Client
+# =============================================================================
+
+module Equipoise
+  class Configuration
+    DEFAULT_BASE_URL     = "https://app.equipoi.se/api/v1"
+    DEFAULT_OPEN_TIMEOUT = 5
+    DEFAULT_READ_TIMEOUT = 15
+    DEFAULT_MAX_RETRIES  = 2
+    LOOPBACK_HOSTS       = %w[localhost 127.0.0.1 ::1 [::1]].freeze
+    PRODUCTION_HOST      = URI.parse(DEFAULT_BASE_URL).host # "app.equipoi.se"
+
+    attr_accessor :open_timeout,
+                  :read_timeout,
+                  :max_retries,
+                  :retry_backoff_base,
+                  :max_retry_backoff,
+                  :allow_insecure_http,
+                  :enabled,
+                  :logger,
+                  :user_agent
+    attr_writer :api_key,
+                :base_url,
+                :source
+
+    def initialize(env: ENV)
+      @env                 = env
+      @api_key             = nil
+      @base_url            = nil
+      @source              = nil
+      @open_timeout        = DEFAULT_OPEN_TIMEOUT
+      @read_timeout        = DEFAULT_READ_TIMEOUT
+      @max_retries         = DEFAULT_MAX_RETRIES
+      @retry_backoff_base  = 0.5
+      @max_retry_backoff   = 30
+      @allow_insecure_http = false
+      @enabled             = true
+      @logger              = nil
+      @user_agent          = "equipoise-ruby/#{Equipoise::VERSION}"
+    end
+
+    # — Claude authored — test-mode kill switch (#5). When disabled the client
+    # short-circuits to a no-op before any network call OR validation, so a stray
+    # EQUIPOISE_API_KEY in a producer's test env can never make a live call.
+    def disabled?
+      !enabled
+    end
+
+    # — Claude authored — explicit assignment wins; otherwise read ENV each call
+    # (rotation-aware).
+    def api_key
+      resolve(@api_key, "EQUIPOISE_API_KEY")
+    end
+
+    def base_url
+      resolve(@base_url, "EQUIPOISE_API_URL") || DEFAULT_BASE_URL
+    end
+
+    def source
+      resolve(@source, "EQUIPOISE_SOURCE")
+    end
+
+    def validate!
+      raise ConfigurationError, "api_key is required (set EQUIPOISE_API_KEY or Equipoise.configure)" if api_key.to_s.empty?
+      raise ConfigurationError, "base_url is required" if base_url.to_s.empty?
+
+      ensure_secure_transport!
+      ensure_environment_match!
+      true
+    end
+
+    private
+
+    def resolve(explicit, env_key)
+      return explicit unless explicit.to_s.empty?
+
+      value = @env[env_key]
+      value.to_s.empty? ? nil : value
+    end
+
+    # — Claude authored — never transmit the Bearer key in cleartext to a remote
+    # host. https is always fine; http is allowed only for loopback dev or when
+    # the producer explicitly opts in for a trusted internal endpoint.
+    def ensure_secure_transport!
+      uri = URI.parse(base_url)
+      return if uri.scheme == "https"
+      return if allow_insecure_http
+      return if LOOPBACK_HOSTS.include?(uri.host)
+
+      raise ConfigurationError,
+            "Refusing to send API credentials over plaintext HTTP to #{uri.host.inspect}. " \
+            "Use https://, or set config.allow_insecure_http = true for a trusted internal endpoint."
+    end
+
+    # — Claude authored (#3) — the key prefix encodes its environment (eq_test_ /
+    # eq_live_); refuse the dangerous host mismatches no producer can see coming:
+    # a TEST key pointed at the production host (test creds writing the real CRM)
+    # or a LIVE key pointed at localhost (prod creds in a dev loop). Staging and
+    # custom-domain hosts are intentionally not flagged (no false positives).
+    def ensure_environment_match!
+      host    = URI.parse(base_url).host
+      key_env = api_key.start_with?("eq_live_") ? :live : (api_key.start_with?("eq_test_") ? :test : nil)
+      return if key_env.nil? # non-standard key prefix — don't guess
+
+      if key_env == :test && host == PRODUCTION_HOST
+        raise ConfigurationError,
+              "A test key (eq_test_) is pointed at the production host (#{host}). This would write test " \
+              "credentials into the live CRM. Use a live key, or point base_url at your test/local host."
+      elsif key_env == :live && LOOPBACK_HOSTS.include?(host)
+        raise ConfigurationError,
+              "A live key (eq_live_) is pointed at a local host (#{host}). Use a test key (eq_test_) for " \
+              "local development, or point base_url at the production host."
+      end
+    end
+  end
+end

data/lib/equipoise/contacts.rb

@@ -0,0 +1,149 @@
+# =============================================================================
+# Equipoise::Contacts
+# =============================================================================
+#
+# The contact-sync resource — the producer's main surface. Maps 1:1 onto the
+# receiver's sync endpoints:
+#
+#   sync(external_id:, email:, name:, tags:, …)  → POST /contacts/sync
+#   batch_sync([...])                            → POST /contacts/sync/batch (≤500/call)
+#   deactivate(external_id:)                     → POST /contacts/sync/:id/deactivate
+#   find(external_id:)                           → GET  /contacts/sync/:id
+#
+# `source` defaults to the client's configured source; an explicit arg overrides
+# it per call. Idempotency: pass `idempotency_key:` to make a single sync's retry
+# safe. Batch retries are safe via the receiver's `(source, external_id)` upsert
+# (the receiver does not consume Idempotency-Key on the batch endpoint).
+#
+# Used by: Equipoise::Client#contacts
+# =============================================================================
+
+module Equipoise
+  class Contacts
+    BATCH_LIMIT = 500
+
+    def initialize(client)
+      @client = client
+    end
+
+    # — Claude authored — upsert one contact by (source, external_id). Unknown
+    # attributes (email/name/first_name/last_name/phone/tags/custom_fields/
+    # create_missing_fields) pass straight through; nils are dropped.
+    def sync(external_id:, source: nil, idempotency_key: nil, **attributes)
+      payload = { source: resolve_source(source), external_id: external_id.to_s }
+                .merge(attributes)
+                .compact
+
+      headers = idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+      @client.request(:post, "/contacts/sync", body: payload, headers: headers)
+    end
+
+    # — Claude authored — upsert many contacts. Chunks to ≤500/call and returns a
+    # BatchResult aggregating every per-item result across chunks. It NEVER raises
+    # mid-batch: a per-item server rejection comes back as an `ok: false` item
+    # (the receiver returns 200 per chunk), and a chunk-level transport/HTTP
+    # failure marks that chunk's records failed so earlier chunks' successes are
+    # preserved and the producer can retry only the failures.
+    def batch_sync(records, source: nil, chunk_size: BATCH_LIMIT)
+      default_source = source || @client.config.source
+      prepared       = records.map { |record| prepare_record(record, default_source) }
+      ensure_sources!(prepared)
+
+      items = []
+      prepared.each_slice(chunk_size) { |chunk| items.concat(sync_chunk(chunk)) }
+      BatchResult.new(items)
+    end
+
+    # — Claude authored — deactivate the external link; the Contact is retained.
+    def deactivate(external_id:, source: nil)
+      @client.request(:post, "#{sync_path(external_id)}/deactivate",
+                      query: { source: resolve_source(source) })
+    end
+
+    # — Claude authored — read back the Contact linked to (source, external_id).
+    def find(external_id:, source: nil)
+      @client.request(:get, sync_path(external_id),
+                      query: { source: resolve_source(source) })
+    end
+
+    # — Claude authored — record an external event on the contact's timeline.
+    # `event_type: "subscribed"`/`"unsubscribed"` toggles the contact's email
+    # subscription (state + activity); any other event_type logs a generic
+    # timeline event. `metadata` is a free-form hash of producer context.
+    def record_activity(external_id:, event_type:, source: nil, label: nil, occurred_at: nil, metadata: nil)
+      body = { event_type: event_type, label: label, occurred_at: occurred_at, metadata: metadata }.compact
+      @client.request(:post, "#{sync_path(external_id)}/activity",
+                      query: { source: resolve_source(source) },
+                      body:  body)
+    end
+
+    # Convenience wrappers for the two subscription events.
+    def subscribe(external_id:, source: nil)
+      record_activity(external_id: external_id, event_type: "subscribed", source: source)
+    end
+
+    def unsubscribe(external_id:, source: nil)
+      record_activity(external_id: external_id, event_type: "unsubscribed", source: source)
+    end
+
+    private
+
+    def prepare_record(record, default_source)
+      record = Util.symbolize_keys(record)
+      record[:source] ||= default_source
+      record[:external_id] = record[:external_id].to_s if record[:external_id]
+      record.compact
+    end
+
+    # Fail fast locally (like single sync) when any record has no source, rather
+    # than shipping a source-less contact and getting an opaque server 422.
+    def ensure_sources!(prepared)
+      missing = prepared.select { |record| record[:source].to_s.empty? }
+      return if missing.empty?
+
+      ids = missing.map { |record| record[:external_id] }.compact
+      raise ArgumentError,
+            "source is required for every batch record (missing for: #{ids.join(', ')}); " \
+            "configure Equipoise.source or pass source:"
+    end
+
+    def sync_chunk(chunk)
+      response = @client.request(:post, "/contacts/sync/batch",
+                                 body: { contacts: chunk },
+                                 headers: { "Idempotency-Key" => chunk_idempotency_key(chunk) })
+      array_data(response.data)
+    rescue Equipoise::ApiError, Equipoise::ConnectionError => e
+      chunk.map { |record| failed_item(record, e) }
+    end
+
+    def array_data(data)
+      data.is_a?(Array) ? data : []
+    end
+
+    def failed_item(record, error)
+      status = error.respond_to?(:code) && error.code ? error.code : "error"
+      { "external_id" => record[:external_id], "status" => status, "ok" => false, "errors" => Array(error.message) }
+    end
+
+    def resolve_source(source)
+      resolved = source || @client.config.source
+      raise ArgumentError, "source is required (configure Equipoise.source or pass source:)" if resolved.to_s.empty?
+
+      resolved
+    end
+
+    # external_id may contain dots/spaces (e.g. "stripe.cus_42"); url-encode the
+    # path segment while leaving unreserved characters (incl. ".") intact.
+    def sync_path(external_id)
+      "/contacts/sync/#{ERB::Util.url_encode(external_id.to_s)}"
+    end
+
+    # Deterministic per-chunk key from the chunk contents: identical contents →
+    # identical key (a safe replay when/if the receiver honors it on batch),
+    # different contents → different key (no false replay). Forward-compatible;
+    # batch idempotency today rests on the (source, external_id) upsert.
+    def chunk_idempotency_key(chunk)
+      "batch-#{Digest::SHA256.hexdigest(JSON.generate(chunk))[0, 32]}"
+    end
+  end
+end

data/lib/equipoise/custom_fields.rb

@@ -0,0 +1,61 @@
+# =============================================================================
+# Equipoise::CustomFields
+# =============================================================================
+#
+# Manage a producer's typed custom-field definitions (the schema the producer
+# owns). Values themselves ride along on a contact sync via
+# `custom_fields: { key: value }`; this resource is for declaring/inspecting the
+# field definitions up front.
+#
+#   declare(key:, field_type:, options:, source:)  → POST  /custom_fields (upsert)
+#   list(customizable_type:)                        → GET   /custom_fields
+#   get(key)                                        → GET   /custom_fields/:key
+#   update(key, label:, …)                          → PATCH /custom_fields/:key
+#   delete(key, purge_values:)                      → DELETE /custom_fields/:key
+#
+# Used by: Equipoise::Client#custom_fields
+# =============================================================================
+
+module Equipoise
+  class CustomFields
+    def initialize(client)
+      @client = client
+    end
+
+    def list(customizable_type: nil, page: nil, per_page: nil)
+      query = { customizable_type: customizable_type, page: page, per_page: per_page }.compact
+      @client.request(:get, "/custom_fields", query: query)
+    end
+
+    def get(key, customizable_type: nil)
+      query = { customizable_type: customizable_type }.compact
+      @client.request(:get, field_path(key), query: query)
+    end
+
+    # — Claude authored — create-or-update a field by key (server returns 201 vs
+    # 200). `customizable_type` from the body is ignored server-side (defaults to
+    # Contact); a client can't declare fields on arbitrary owner types.
+    def declare(key:, **attributes)
+      @client.request(:post, "/custom_fields", body: { custom_field: { key: key, **attributes }.compact })
+    end
+    alias upsert declare
+
+    def update(key, **attributes)
+      @client.request(:patch, field_path(key), body: { custom_field: attributes.compact })
+    end
+
+    # Returns true on a 204. Pass purge_values: true to delete a field that has
+    # values (otherwise the server replies 409).
+    def delete(key, purge_values: false)
+      query = purge_values ? { purge_values: true } : {}
+      @client.request(:delete, field_path(key), query: query)
+      true
+    end
+
+    private
+
+    def field_path(key)
+      "/custom_fields/#{ERB::Util.url_encode(key.to_s)}"
+    end
+  end
+end

data/lib/equipoise/errors.rb

@@ -0,0 +1,129 @@
+# =============================================================================
+# Equipoise errors
+# =============================================================================
+#
+# Typed exception hierarchy so producers can rescue precisely:
+#
+#   Equipoise::Error                — base for everything the gem raises
+#     ├─ ConfigurationError         — missing api_key/base_url (raised locally)
+#     ├─ ConnectionError            — network failure after bounded retries
+#     └─ ApiError                   — the server returned a non-2xx
+#          ├─ AuthenticationError   — 401 (missing/invalid/expired/revoked key)
+#          ├─ ForbiddenError        — 403 (missing scope / forbidden_source)
+#          ├─ NotFoundError         — 404
+#          ├─ ConflictError         — 409 (sync race / locked custom field)
+#          ├─ ValidationError       — 422 (#details carries the field errors)
+#          ├─ RateLimitError        — 429 (#retry_after seconds)
+#          └─ ServerError           — 5xx
+#
+# ApiError.from_response builds the right subclass from a parsed Response,
+# tolerating both the `{error:{code,message,details}}` envelope and the legacy
+# rack-attack `{error:"Rate limit exceeded", retry_after:…}` body.
+#
+# Used by: Equipoise::Client, every resource
+# =============================================================================
+
+module Equipoise
+  class Error < StandardError
+    # — Claude authored — the retry taxonomy lives in the gem so no producer has
+    # to memorize which failures are transient. Base default: not retryable.
+    # A producer's job becomes: `rescue Equipoise::Error => e; raise if e.retryable?`.
+    def retryable?
+      false
+    end
+  end
+
+  class ConfigurationError < Error; end
+
+  # A transport failure (timeout, refused, DNS, TLS). Always worth a retry.
+  class ConnectionError < Error
+    def retryable?
+      true
+    end
+  end
+
+  class ApiError < Error
+    attr_reader :status, :code, :details, :response
+
+    def initialize(message = nil, status: nil, code: nil, details: nil, response: nil)
+      super(message)
+      @status   = status
+      @code     = code
+      @details  = details
+      @response = response
+    end
+
+    # 429 + any 5xx are transient (back off and retry); every 4xx is a permanent
+    # client error the producer must fix (validation, auth, scope, not-found).
+    def retryable?
+      status == 429 || status.to_i >= 500
+    end
+
+    # — Claude authored — pick the subclass by HTTP status and parse the error
+    # envelope. Robust to an empty body (401) and the legacy string error body.
+    def self.from_response(response)
+      status  = response.status
+      body    = response.body
+      payload = body.is_a?(Hash) ? body["error"] : nil
+
+      code, message, details =
+        if payload.is_a?(Hash)
+          [payload["code"], payload["message"], payload["details"]]
+        elsif payload.is_a?(String)
+          [nil, payload, nil]
+        else
+          [nil, nil, nil]
+        end
+
+      message ||= default_message(status)
+      klass     = class_for(status)
+
+      if klass == RateLimitError
+        klass.new(message, status: status, code: code, details: details,
+                           response: response, retry_after: response.retry_after)
+      else
+        klass.new(message, status: status, code: code, details: details, response: response)
+      end
+    end
+
+    def self.class_for(status)
+      case status
+      when 401 then AuthenticationError
+      when 403 then ForbiddenError
+      when 404 then NotFoundError
+      when 409 then ConflictError
+      when 422 then ValidationError
+      when 429 then RateLimitError
+      when 500..599 then ServerError
+      else ApiError
+      end
+    end
+
+    def self.default_message(status)
+      {
+        401 => "Unauthorized",
+        403 => "Forbidden",
+        404 => "Not found",
+        409 => "Conflict",
+        422 => "Validation failed",
+        429 => "Rate limit exceeded"
+      }.fetch(status) { status >= 500 ? "Server error" : "Request failed (#{status})" }
+    end
+  end
+
+  class AuthenticationError < ApiError; end
+  class ForbiddenError < ApiError; end
+  class NotFoundError < ApiError; end
+  class ConflictError < ApiError; end
+  class ValidationError < ApiError; end
+  class ServerError < ApiError; end
+
+  class RateLimitError < ApiError
+    attr_reader :retry_after
+
+    def initialize(message = nil, retry_after: nil, **opts)
+      super(message, **opts)
+      @retry_after = retry_after
+    end
+  end
+end

data/lib/equipoise/railtie.rb

@@ -0,0 +1,17 @@
+# =============================================================================
+# Equipoise::Railtie (loaded only under Rails)
+# =============================================================================
+#
+# When the gem is required inside a Rails app, make the optional Syncable concern
+# available without a manual require. The generator (`rails g equipoise:install`)
+# writes the initializer. Plain Ruby usage never touches this file.
+#
+# Used by: lib/equipoise.rb (required only when Rails::Railtie is defined)
+# =============================================================================
+
+require "equipoise/syncable"
+
+module Equipoise
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/equipoise/response.rb

@@ -0,0 +1,68 @@
+# =============================================================================
+# Equipoise::Response
+# =============================================================================
+#
+# A thin wrapper over a successful API response: the HTTP status, the
+# (downcased) header hash, and the parsed JSON body. The whole API uses a
+# `{ data, meta }` envelope, so `#data` / `#meta` unwrap it, and `#sync_status`
+# surfaces the `meta.sync_status` ("created" | "updated") the sync endpoints add.
+#
+# `#retry_after` is the single Retry-After parser for the whole gem (used by both
+# the retry-loop backoff and the surfaced RateLimitError): it reads the standard
+# header, falls back to the legacy rack-attack body `retry_after`, and supports
+# BOTH delta-seconds and the RFC 7231 HTTP-date form.
+#
+# Used by: Equipoise::Client, Equipoise::Contacts, Equipoise::CustomFields, ApiError
+# =============================================================================
+
+module Equipoise
+  class Response
+    attr_reader :status, :headers, :body
+
+    def initialize(status:, headers:, body:)
+      @status  = status
+      @headers = headers || {}
+      @body    = body
+    end
+
+    def success?
+      (200..299).cover?(status)
+    end
+
+    # The envelope's `data` (Hash or Array). Falls back to the whole body when a
+    # response isn't enveloped (defensive — every documented 2xx is).
+    def data
+      body.is_a?(Hash) && body.key?("data") ? body["data"] : body
+    end
+
+    def meta
+      body.is_a?(Hash) ? (body["meta"] || {}) : {}
+    end
+
+    def sync_status
+      meta["sync_status"]
+    end
+
+    # Seconds to wait, from the Retry-After header or the legacy body field.
+    # Returns an Integer (or nil when neither is present / unparseable).
+    def retry_after
+      raw = headers["retry-after"]
+      raw = body["retry_after"] if raw.to_s.empty? && body.is_a?(Hash)
+      parse_retry_after(raw)
+    end
+
+    private
+
+    def parse_retry_after(raw)
+      value = raw.to_s.strip
+      return nil if value.empty?
+      return value.to_i if value.match?(/\A\d+\z/) # delta-seconds
+
+      # RFC 7231 also allows an HTTP-date; convert to seconds-from-now (≥ 0).
+      seconds = (Time.httpdate(value) - Time.now).ceil
+      seconds.negative? ? 0 : seconds
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/equipoise/syncable.rb

@@ -0,0 +1,78 @@
+# =============================================================================
+# Equipoise::Syncable (optional Rails add-on)
+# =============================================================================
+#
+# Mix into a producer's model to keep an Equipoise Contact in lockstep with it.
+# Dependency-free (no ActiveSupport required): when the host responds to
+# `after_commit` (an ActiveRecord model), it wires the create/update hook;
+# otherwise it's inert, so a PORO can include it for testing.
+#
+#   class User < ApplicationRecord
+#     include Equipoise::Syncable
+#
+#     def equipoise_external_id      = id.to_s
+#     def equipoise_contact_attributes
+#       { email:, name: full_name, tags: ["AMP"] }
+#     end
+#
+#     # call from your soft-delete path:
+#     def soft_delete_account!
+#       super
+#       deactivate_from_equipoise
+#     end
+#   end
+#
+# The default `equipoise_sync!` posts inline; in production wrap it in a job
+# (override `equipoise_sync!` to enqueue) so a web request never blocks on the
+# round-trip. In dev, ensure the queue runs inline or the post never fires.
+#
+# Producer-side firing is exercised in AMP (S13); the gem suite tests the
+# transport methods directly.
+#
+# Used by: producer models that opt in (e.g. AMP's User)
+# =============================================================================
+
+module Equipoise
+  module Syncable
+    def self.included(base)
+      return unless base.respond_to?(:after_commit)
+
+      base.after_commit :equipoise_sync!, on: [:create, :update]
+    end
+
+    # Override to enqueue instead of posting inline. No-op until configured so a
+    # boot before credentials exist (or a test env) doesn't make live calls.
+    # Rescues Equipoise::Error so a transient API/transport failure in this
+    # after_commit hook never propagates out of the host's `save!` (Rails 7.1+
+    # re-raises after_commit exceptions). Best-effort, like envelope tracking.
+    # Host bugs (a NoMethodError in equipoise_contact_attributes) still surface.
+    def equipoise_sync!
+      return unless Equipoise.configured?
+
+      sync_to_equipoise
+    rescue Equipoise::Error => e
+      Equipoise.configuration.logger&.warn(
+        "[equipoise] sync failed for #{self.class}##{equipoise_external_id}: #{e.message}"
+      )
+    end
+
+    def sync_to_equipoise
+      Equipoise.client.contacts.sync(external_id: equipoise_external_id, **equipoise_contact_attributes)
+    end
+
+    def deactivate_from_equipoise
+      Equipoise.client.contacts.deactivate(external_id: equipoise_external_id)
+    end
+
+    # — Sensible default; override in the host model when the external id isn't
+    # the primary key.
+    def equipoise_external_id
+      id.to_s
+    end
+
+    # Host models MUST implement this — the attributes posted on each sync.
+    def equipoise_contact_attributes
+      raise NotImplementedError, "#{self.class} must define #equipoise_contact_attributes"
+    end
+  end
+end

data/lib/equipoise/util.rb

@@ -0,0 +1,25 @@
+# =============================================================================
+# Equipoise::Util
+# =============================================================================
+#
+# Small stateless helpers shared across the gem. Currently just the symbol-key
+# transform used by both Contacts (normalizing caller records) and BatchResult
+# (normalizing server per-item results) — kept in one place so the two can't
+# drift.
+#
+# Used by: Equipoise::Contacts, Equipoise::BatchResult
+# =============================================================================
+
+module Equipoise
+  module Util
+    module_function
+
+    # — Claude authored — shallow string→symbol key transform; passes non-Hash
+    # input through untouched.
+    def symbolize_keys(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) { |(key, value), out| out[key.to_sym] = value }
+    end
+  end
+end

data/lib/equipoise/version.rb

@@ -0,0 +1,12 @@
+# =============================================================================
+# Equipoise::VERSION
+# =============================================================================
+#
+# Single source of truth for the gem version, read by the gemspec and exposed
+# at runtime. Pre-1.0 while the gem is proven against AMP before any public
+# RubyGems publish.
+# =============================================================================
+
+module Equipoise
+  VERSION = "0.1.0"
+end