contractful 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 895b5ad950f42663bcb0851f6acda44c9d2c183acacc97ff7fa10797f62e276a
+  data.tar.gz: 35164be35c17465d632673db30dca00724e978688e0e16ba8aae2b8ee887baae
+SHA512:
+  metadata.gz: 79a242d59942954f6f86f1d4f887450410a3a75d4e431f14af20d121f553c35750c6db0567d99b65b3bf02242f62c16b7630296cd81fcbc2b2fc0b08401d1830
+  data.tar.gz: f72f2aeccabfd522c68dd6b03869646e22980bea34449b3b60c4c527a1b5b194ea3cb2f965e493ec76dac9e92472266a4f1f5a916ec9a0d67457582d145c68be

data/API.md

@@ -0,0 +1,142 @@
+# API — public surface reference
+
+This document is the normative list of contractful's public API. Names
+documented here are covered by semantic versioning: removing or changing one
+requires a major release. Anything not listed here (underscore-prefixed
+machinery like `__own_contract_config`, private helpers) is internal and may
+change in any release. The contract-first layer is part of the public surface
+and follows the same rules. Version markers in parentheses refer to the
+upstream rest-client release line in which a feature first appeared;
+contractful 0.1.0 ships all of them.
+
+## Module-level entry points
+
+```ruby
+Contractful.get(url, headers = {})
+Contractful.post(url, payload, headers = {})
+Contractful.put(url, payload, headers = {})
+Contractful.patch(url, payload, headers = {})
+Contractful.delete(url, headers = {})
+Contractful.head(url, headers = {})
+Contractful.options(url, headers = {})
+Contractful::Request.execute(options)   # full option surface, returns Response
+```
+
+Non-2xx responses raise the mapped exception unless a block is given (block
+form returns the response and lets the caller decide — see README "Result
+handling").
+
+## Request options
+
+All accepted by `Request.execute` (and the corresponding per-call contract
+meta options):
+
+| Option | Meaning |
+| --- | --- |
+| `:method`, `:url` | Verb symbol and target URL (required) |
+| `:payload` | Hash/ParamsArray (form or JSON), String, IO/stream, or multipart file parts |
+| `:headers` | Header hash |
+| `:user`, `:password` | Basic-auth credentials |
+| `:timeout`, `:open_timeout`, `:read_timeout`, `:write_timeout` | Total and phase timeouts (seconds) |
+| `:max_redirects` | Redirect cap (default 10) |
+| `:ssl_ca_file`, `:ssl_client_cert`, `:ssl_client_key` | TLS trust and client identity |
+| `:ssl_min_version`, `:ssl_max_version` | Protocol floor/ceiling; normalized via `normalize_ssl_version` (accepts `:TLSv1_2`-style symbols, `:TLS1_2`-style symbols and OpenSSL constants) |
+| `:verify_ca` / `:verify_callback` | Certificate verification control |
+| `:cookies` | Cookie hash or jar |
+| `:persistent` | Use the keep-alive connection pool (2.3+) |
+| `:max_retries`, `:retry_interval` | Automatic retry count and base delay (exponential backoff) (2.3+) |
+| `:idempotent` | Repeating the request has the same effect as sending it once. Defaults to true for GET, HEAD, OPTIONS, TRACE, PUT and DELETE (RFC 9110), false otherwise. A positive `:max_retries` requires it to be true. |
+| `:retry_after`, `:max_retry_after` | Honor server `Retry-After` and cap its value (2.5+) |
+| `:log` | Per-request logger override |
+| `:block_response` | Raw response handler |
+
+## Resource
+
+```ruby
+site = Contractful::Resource.new('https://api.example.com', user:, password:, headers:)
+site['orders'].get                      # nested path resources
+site['orders'].post(payload_hash)       # same option surface as Request
+```
+
+## Response
+
+`Contractful::Response` is a String-like object (`#body`, `#to_s`) plus:
+
+| Method | Meaning |
+| --- | --- |
+| `#code` / `#to_i` | HTTP status |
+| `#headers` | Downcased header hash |
+| `#raw_headers` | Original header block |
+| `#history` | Redirect chain responses |
+| `#cookies`, `#cookie_jar` | Set cookies as hash / jar |
+| `#json(**opts)` | JSON.parse of the body (2.3+) |
+| `#rate_limit` | Parsed `RateLimit` or `nil` when absent (2.5+) |
+| `#rate_limited?` | Strict boolean: 429 or exhausted quota (2.5+) |
+
+## Exceptions
+
+```text
+Contractful::Exception < RuntimeError          # .response .http_code .http_body .http_headers .retryable?
+├── ExceptionWithResponse                      # retryable? = status in RETRIABLE_STATUSES
+│   ├── RequestFailed                          # unmapped failure statuses
+│   │   └── one class per HTTP status: NotFound, Unauthorized, Conflict,
+│   │       TooManyRequests, InternalServerError, ... (+ legacy aliases)
+│   └── Exceptions::Timeout < RequestTimeout
+│       ├── OpenTimeout  ├── ReadTimeout  └── WriteTimeout (2.3+)
+├── ServerBrokeConnection
+└── SSLCertificateNotVerified
+```
+
+Classification: `Contractful::Exceptions::RETRIABLE_STATUSES` is
+`[408, 425, 429, 500, 502, 503, 504]`; `Exceptions.retryable?(status_or_exception)`
+also classifies network errors (`SocketError`, `Errno::*`, `Net::*Timeout`,
+`::Timeout::Error`). All other statuses are terminal — retrying will not fix
+a bad token or a bad payload.
+
+## Contract DSL (`Contractful::Contract`)
+
+Class-level macros (on the client class):
+
+| Macro | Meaning |
+| --- | --- |
+| `base(url)` | Absolute http(s) base URL; trailing slashes stripped |
+| `default_headers(hash)` | Merged down the ancestor chain (reader form with no args) |
+| `strict_params(flag)` | Strict unknown-param rejection (default on) |
+| `payload_style(:json \| :form)` | Class default payload routing |
+| `auth bearer: / api_key: / basic:` | Scheme declaration; values may be callables, invoked per request; `api_key:` accepts an array for dual-header schemes and `in: :query` |
+| `idempotency_header(name)`, `idempotency_generator(callable)` | Key header customization |
+| `before_request { \|ctx\| }` | Mutable context: `definition:, method:, url:, headers:, payload:, query:, cookies:` |
+| `after_response { \|resp\| }` | Observe validated responses |
+| `resource :posts, path:, only:, except:, update_with:, singular:` | Generates the five CRUD contracts (non-strict) |
+| `contract :name, 'VERB /path' do ... end` | Declare one operation |
+
+Inside a contract block:
+
+| Declaration | Meaning |
+| --- | --- |
+| `param :name, Type, required:, default:, inclusion:, min:, max:, length:, pattern:, coerce:, description:, header:, cookie:` | Closed-schema param (String, Integer, Float, `:boolean`, Array, Hash, any class, any Proc). `header:` / `cookie:` send the value as that request header or cookie instead of the query or payload; they take a scalar type only and cannot be a path placeholder |
+| `responds 200, (200..299), type: Array/:hash/:json/...` | Expected statuses + body shape; declaring 4xx/5xx converts them to returned values and judges everything by the contract |
+| `response_field :name, type, required:, strict:` | Open-schema response binding: required+type bind; undeclared fields are data |
+| `verify_response { \|resp, parsed\| }` | Custom assertion; falsey raises `UnexpectedResponse` |
+| `paginated style: :cursor, cursor_param:, next_cursor_path:, items_path:` / `style: :offset, offset_param:, limit_param:, has_more_path:` | Pagination strategy |
+| `idempotent true` | Inject a stable idempotency key header |
+| `auth false` | Opt out of class auth |
+| `payload_style`, `strict_params` | Per-contract overrides |
+
+Per-call meta options: `_headers`, `_timeout`, `_open_timeout`,
+`_read_timeout`, `_write_timeout`, `_persistent`, `_max_retries`,
+`_retry_interval`, `_idempotency_key`, `_max_pages`.
+
+Generated per contract `:name`: `name(**params)`, `name_url(**params)`, and
+for paginated contracts `name_pages(**params)` (lazy Enumerator of validated
+pages) and `all_name(**params)` (flat collector). Reflection:
+`contracts`, `contract_names`, `contract?`, `contract_for`,
+`Definition#describe`; dynamic dispatch conveniences `call_*`, `*_contract`,
+`has_*?` with `respond_to_missing?` support. Instance-level overrides:
+`Client.new(base:, headers:)`.
+
+Contract errors, all rooted at `Contractful::Contract::Error`:
+`InvalidDefinition` (declaration time), `MissingBaseUrl`, `MissingParam`,
+`UnknownParam`, `InvalidParam` (pre-flight), `UnexpectedResponse`
+(`#response` attached; response-contract violations), `PaginationError`
+(missing stop condition / `_max_pages` exceeded).

data/ARCHITECTURE.md

@@ -0,0 +1,134 @@
+# ARCHITECTURE — System architecture
+
+contractful is a layered Ruby library with a deliberately thin core: one
+request pipeline used by every entry point, a transport that is Net::HTTP,
+and a metaprogrammed contract layer that compiles declarations into real
+methods on top of that pipeline. There is no runtime, no daemon, no external
+service dependency — the gem is loaded into the host process and makes HTTP
+calls on demand.
+
+## Layer diagram
+
+```text
+┌────────────────────────────────────────────────────────────┐
+│ Contract layer — Contractful::Contract                     │
+│   DSL macros → Definition → Executor → define_method      │
+│   typed params · response contracts · auth · idempotency   │
+│   pagination · rate-limit · callbacks · reflection         │
+├────────────────────────────────────────────────────────────┤
+│ High-level API — Contractful.get/post/... · Resource        │
+├────────────────────────────────────────────────────────────┤
+│ Request pipeline — Contractful::Request                     │
+│   payload normalization (Payload, ParamsArray)             │
+│   auth (user/password, netrc) · cookies · redirects        │
+│   retries + backoff · Retry-After · connection pool        │
+├────────────────────────────────────────────────────────────┤
+│ Transport — Net::HTTP + OpenSSL                            │
+│   ssl_min/max_version normalization · timeouts             │
+├────────────────────────────────────────────────────────────┤
+│ Response side — AbstractResponse · Response · RawResponse  │
+│   headers · history · #json · RateLimit parsing            │
+├────────────────────────────────────────────────────────────┤
+│ Errors — Contractful::Exception hierarchy                   │
+│          Contractful::Contract::Error hierarchy             │
+└────────────────────────────────────────────────────────────┘
+```
+
+## Module map
+
+| Module | Responsibility |
+| --- | --- |
+| `lib/contractful.rb` | Facade: module-level verb methods, `Contractful.log`, version |
+| `request.rb` | The pipeline: option validation, payload/params prep, transmission, redirects, retries, timeouts, SSL setup |
+| `payload.rb` | Payload normalization: form, JSON, raw, multipart, streaming; `rewind` for retries |
+| `params_array.rb` | Ordered param lists with repeated keys and nested notation |
+| `resource.rb` | ActiveResource-style wrapper around `Request` |
+| `abstract_response.rb` | Shared response behavior: headers, code, cookies, history |
+| `response.rb` | Concrete String-like response body with `.json`, `.rate_limit` |
+| `raw_response.rb` | File-backed response for streaming downloads |
+| `connection_pool.rb` | Thread-safe keep-alive pool (`persistent: true`) |
+| `rate_limit.rb` | IETF `RateLimit-*` / legacy `X-RateLimit-*` parsing |
+| `exceptions.rb` | Status→exception map, `RETRIABLE_STATUSES`, `Exceptions.retryable?` |
+| `contract.rb` | Contract error hierarchy + the `include` hook wiring the DSL |
+| `contract/dsl.rb` | Class macros (`base`, `contract`, `resource`, `auth`, ...), `define_method` generation, reflection |
+| `contract/definition.rb` | One operation: params, responses, path expansion |
+| `contract/param.rb` | Typed param: coercion + closed-schema constraints (`min/max/length/pattern/inclusion`) |
+| `contract/response_field.rb` | Open-schema response field bindings |
+| `contract/auth.rb` | `bearer:` / `api_key:` / `basic:` resolution to headers |
+| `contract/pagination.rb` | Cursor/offset iteration + `PaginationError` guard |
+| `contract/executor.rb` | Per-call execution: validate → build → send → verify → callbacks |
+| `contract/config.rb` | Per-class config objects + ancestor-chain merging |
+| `windows/root_certs.rb` | Windows certificate store loading (separate platform gem) |
+
+## Request lifecycle
+
+1. **Entry.** A call arrives: `Contractful.get`, `Resource#get`, or a
+   generated contract method (`Contract::Executor.call`).
+2. **Contract validation (contract path only).** Params are coerced and
+   checked against the `Definition` — required, type, `inclusion:`,
+   `min/max/length/pattern`, strict unknown-param rejection. Any violation
+   raises (`MissingParam`/`UnknownParam`/`InvalidParam`) **before** the
+   network is touched. Path placeholders are expanded and URI-escaped;
+   remaining params are routed to query string or JSON/form payload by verb
+   and `payload_style`.
+3. **Request assembly.** `Request` validates options, normalizes the payload
+   (`Payload::Base` family), merges headers, resolves auth (contract auth
+   first, then `before_request` callbacks may adjust everything through the
+   mutable context), loads netrc credentials, and applies cookies.
+4. **Connection.** With `persistent: true` the request checks a connection
+   out of `Contractful::ConnectionPool` (keyed by host/port/proxy/SSL); the
+   key must include the client-certificate fingerprint so credentials never
+   leak across pool entries. Otherwise a fresh `Net::HTTP` is configured:
+   SSL versions normalized via `normalize_ssl_version`, timeouts applied
+   (`open/read/write`), proxy resolved from options or ENV.
+5. **Transmission with retries.** The request transmits; on a retryable
+   network failure (`Timeout`, `ECONNRESET`, `EPIPE`, ...) or a retryable
+   HTTP status (408, 425, 429, 500, 502, 503, 504) and `:max_retries > 0`,
+   it waits — honoring `Retry-After` (delta or HTTP-date, capped by
+   `:max_retry_after`) or exponential backoff — rewinds the payload and
+   retries with any idempotency key kept stable.
+6. **Response validation.** Classic path: non-2xx raises the mapped
+   exception (`Contractful::NotFound`, ...) with the response attached.
+   Contract path: the status must be in the declared set, the body must
+   satisfy the declared type and `response_field` bindings, and any
+   `verify_response` block must pass — otherwise
+   `Contract::UnexpectedResponse` (with the response attached). Declared
+   error statuses are returned as values instead of raised (redirects still
+   followed); contracts without declarations keep classic behavior.
+7. **Delivery.** `after_response` callbacks observe the validated response;
+   rate-limit headers are parsed onto `response.rate_limit`; the connection
+   is checked back in; the response (or collected page) returns to the
+   caller.
+
+## Deliberate architecture decisions
+
+- **Net::HTTP is the only transport.** No pluggable transport abstraction
+  exists today; the per-request meta options (`_persistent`, `_timeout`,
+  ...) and SSL normalization are typed against what Net::HTTP actually
+  supports. This keeps the surface honest — see ADR
+  [0002](adr/0002-contract-first-client-layer.md) for why the contract layer
+  also avoids a schema-engine dependency.
+- **Generated methods are real methods.** Contract execution is compiled
+  with `define_method` at declaration time — `method_missing` handles only
+  the convenience families (`call_*`, `*_contract`, `has_*?`) with
+  `respond_to_missing?` support. See ADR
+  [0003](adr/0003-metaprogrammed-client-generation.md).
+- **One global mutable, thread-safe resource:** the default connection pool.
+  Everything else is per-request or per-client-class state.
+- **`frozen_string_literal: true` everywhere**; request/response objects
+  never mutate caller-supplied option hashes.
+
+## Development-time architecture
+
+- **Tests:** RSpec, WebMock for offline integration; contract specs mirror
+  the DSL surface under `spec/unit/contract/`; a small live suite against
+  httpbin.org runs in CI (see
+  [docs/engineering/TESTING.md](docs/engineering/TESTING.md)).
+- **CI:** GitHub Actions matrix Ruby 3.0→4.0 + experimental `ruby-head`,
+  `permissions: contents: read`
+  ([.github/workflows/ci.yml](.github/workflows/ci.yml)).
+- **Packaging:** two gemspecs from one source — the Ruby platform gem and
+  the Windows gem (`ffi`-based root certificate store, `x64-mingw-ucrt`).
+
+The security architecture — trust boundaries, TLS posture, threat model —
+lives in [docs/security/THREAT_MODEL.md](docs/security/THREAT_MODEL.md).

data/AUTHORS

@@ -0,0 +1,106 @@
+The Ruby REST Client would not be what it is today without the help of
+the following kind souls:
+
+Adam Jacob
+Adam Wiggins
+Adrian Rangel
+Alex Tomlins
+Aman Gupta
+Andy Brody
+Avi Deitcher
+Blake Mizerany
+Brad Ediger
+Braintree
+Brian Donovan
+Caleb Land
+Chris Dinn
+Chris Frohoff
+Chris Green
+Coda Hale
+Crawford
+Cyril Rohr
+Dan Mayer
+Dario Hamidi
+Darren Coxall
+David Backeus
+David Perkowski
+Dmitri Dolguikh
+Dusty Doris
+Dylan Egan
+El Draper
+Evan Broder
+Evan Smith
+François Beausoleil
+Gabriele Cirulli
+Garry Shutler
+Giovanni Cappellotto
+Greg Borenstein
+Harm Aarts
+Hiro Asari
+Hugh McGowan
+Ian Warshak
+Igor Zubkov
+Ivan Makfinsky
+JH. Chabran
+James Edward Gray II
+Jari Bakken
+Jeff Pereira
+Jeff Remer
+Jeffrey Hardy
+Jeremy Kemper
+Joe Rafaniello
+John Barnette
+Jon Rowe
+Jordi Massaguer Pla
+Joshua J. Campoverde
+Juan Alvarez
+Julien Kirch
+Jun Aruga
+Justin Coyne
+Justin Lambert
+Keith Rarick
+Kenichi Kamiya
+Kevin Read
+Kosuke Asami
+Kyle Meyer
+Kyle VanderBeek
+Lars Gierth
+Lawrence Leonard Gilbert
+Lee Jarvis
+Lennon Day-Reynolds
+Lin Jen-Shin
+Magne Matre Gåsland
+Marc-André Cournoyer
+Marius Butuc
+Matthew Manning
+Michael Klett
+Michael Rykov
+Michael Westbom
+Mike Fletcher
+Nelson Elhage
+Nicholas Wieland
+Nick Hammond
+Nick Plante
+Niko Dittmann
+Nikolay Shebanov
+Oscar Del Ben
+Pablo Astigarraga
+Paul Dlug
+Pedro Belo
+Pedro Chambino
+Philip Corliss
+Pierre-Louis Gottfrois
+Rafael Ssouza
+Richard Schneeman
+Rick Olson
+Robert Eanes
+Rodrigo Panachi
+Sam Norbury
+Samuel Cochran
+Syl Turner
+T. Watanabe
+Tekin
+W. Andrew Loe III
+Waynn Lue
+Xavier Shay
+tpresa

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for
+moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement through
+[GitHub's report content interface](https://docs.github.com/en/communities/moderating-comments-and-conversations/managing-reports-in-your-repository)
+on this repository. All complaints will be reviewed and investigated promptly
+and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the
+[Contributor Covenant](https://www.contributor-covenant.org), version 2.1,
+available at
+https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2008-2014 Rest Client Authors
+
+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.