sinatra-unirate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd7e1bb21ba1426d6905e2cc791210fcd6b455eb16f76b20383038f1a926443d
+  data.tar.gz: 429c7bc86582eb904d8774b3c9d09c8506615226abfd648b7ea1dcc691bf2115
+SHA512:
+  metadata.gz: ad5415d873ceb4fd631125537e62c41f9050ecc9e30aec0482d54c1f008520dd813b5d15e41f73197961762700b29b4b46271e65b2985b384592874409b314f1
+  data.tar.gz: 26b6007155df60b37beb909da5bdc94ad2a4b413a06be9e0d0a85dd0cd6a06c7d072b035ee94b89bdb3ae85448580f23e1f1f1f786ab8831ba31c4142c6ce827

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based
+on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-07-20
+
+### Added
+
+- Initial release.
+- `Sinatra::UniRate` — a Sinatra extension registered via
+  `register Sinatra::UniRate` in classic or modular apps.
+- Settings-based configuration: `:unirate_api_key` (with an
+  `UNIRATE_API_KEY` env-var fallback), `:unirate_base_url`,
+  `:unirate_timeout`, `:unirate_default_currency`,
+  `:unirate_enable_historical`, and `:unirate_mount_routes`.
+- Route/view helpers `unirate_rate`, `unirate_convert`, `unirate_currencies`,
+  and `unirate_vat`, plus `unirate_client`.
+- Optional mountable JSON proxy routes (`GET /unirate/rate`,
+  `GET /unirate/convert`, `GET /unirate/currencies`) enabled by
+  `set :unirate_mount_routes, true`.
+- `UniRate::SinatraClient` — stdlib-only (`net/http` + `json`) client exposing
+  `get_rate`, `convert`, `get_supported_currencies`, `get_vat_rates`, and the
+  Pro-gated `get_historical_rate`, with full HTTP error mapping.
+- Historical endpoint feature-flagged off by default (Pro-gated / 403 on the
+  free tier).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unirate Team
+
+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,163 @@
+# sinatra-unirate
+
+A [Sinatra](https://sinatrarb.com) extension for the
+[UniRate API](https://unirateapi.com) — free, real-time currency exchange
+rates, conversion, supported-currency listings, and VAT rates, wired straight
+into your Sinatra app.
+
+- `register Sinatra::UniRate` in classic **or** modular apps
+- Settings-based configuration (`set :unirate_api_key, ...`), or read the key
+  from `UNIRATE_API_KEY` automatically
+- Route/view helpers — `unirate_rate`, `unirate_convert`, `unirate_currencies`,
+  `unirate_vat` — available in every route and view
+- Optional mountable JSON proxy routes so your frontend never sees the API key
+- `unirate_client` — a plain client for service objects
+- 170+ currencies (fiat + crypto) via UniRate
+- Free tier, no credit card required
+- **Zero runtime dependencies beyond Sinatra** (pure stdlib `net/http` + `json`)
+
+> **Affiliation:** this extension is maintained by the UniRate team and talks to
+> the UniRate API. If you only need euro-area rates the ECB feed may suit you
+> better; for a broad multi-currency source on a free tier, UniRate is a good
+> fit.
+
+## Requirements
+
+- Ruby 3.0+
+- Sinatra 2.0+
+
+## Installation
+
+```ruby
+# Gemfile
+gem "sinatra-unirate"
+```
+
+```bash
+bundle install
+```
+
+## Quick start
+
+### Classic app
+
+```ruby
+require "sinatra"
+require "sinatra/unirate"
+
+set :unirate_api_key, ENV.fetch("UNIRATE_API_KEY") # or leave unset to read the env var lazily
+
+get "/eur" do
+  "100 USD = #{unirate_convert(100, "USD", "EUR")} EUR"
+end
+```
+
+### Modular app
+
+```ruby
+require "sinatra/base"
+require "sinatra/unirate"
+
+class MyApp < Sinatra::Base
+  register Sinatra::UniRate
+  set :unirate_api_key, ENV.fetch("UNIRATE_API_KEY")
+
+  get "/eur" do
+    "100 USD = #{unirate_convert(100, "USD", "EUR")} EUR"
+  end
+end
+```
+
+Get a free API key at [unirateapi.com](https://unirateapi.com).
+
+## Helpers
+
+Available in every route and view once the extension is registered:
+
+```ruby
+unirate_rate("USD", "EUR")        # => 0.92
+unirate_rate("USD")               # => { "EUR" => 0.92, "GBP" => 0.79, ... }
+unirate_convert(100, "USD", "EUR") # => 92.5
+unirate_currencies                # => ["USD", "EUR", "GBP", ...]
+unirate_vat("DE")                 # => { "country_code" => "DE", "vat_rate" => 19.0 }
+unirate_client                    # => UniRate::SinatraClient for advanced use
+```
+
+`unirate_rate` and `unirate_convert` default the base currency to
+`:unirate_default_currency` (`"USD"`) when the `from` argument is omitted.
+
+## JSON proxy routes
+
+Set `:unirate_mount_routes` to add server-side proxy endpoints — the API key
+stays on the server:
+
+```ruby
+set :unirate_mount_routes, true
+```
+
+```
+GET /unirate/rate?from=USD&to=EUR               => { "rate": 0.92 }
+GET /unirate/convert?from=USD&to=EUR&amount=100 => { "result": 92.5 }
+GET /unirate/currencies                         => { "currencies": ["USD", ...] }
+```
+
+Typed UniRate errors are mapped back to their HTTP status.
+
+## Configuration
+
+All configuration is expressed through Sinatra settings:
+
+| Setting                      | Default                      | Description                                          |
+|------------------------------|------------------------------|------------------------------------------------------|
+| `:unirate_api_key`           | `ENV["UNIRATE_API_KEY"]`     | Your UniRate API key.                                |
+| `:unirate_base_url`          | `https://api.unirateapi.com` | API base URL.                                        |
+| `:unirate_timeout`           | `30`                         | HTTP open/read timeout in seconds.                   |
+| `:unirate_default_currency`  | `"USD"`                      | Base used by the one/two-arg helpers.                |
+| `:unirate_enable_historical` | `false`                      | Enable the Pro-gated historical endpoint (see below).|
+| `:unirate_mount_routes`      | `false`                      | Add the `/unirate/*` JSON proxy routes.              |
+
+## Error handling
+
+Every failure raises a subclass of `UniRate::UnirateError`:
+
+| HTTP    | Exception                            |
+|---------|--------------------------------------|
+| 400     | `UniRate::InvalidDateError`          |
+| 401     | `UniRate::AuthenticationError`       |
+| 403     | `UniRate::APIError` (status 403)     |
+| 404     | `UniRate::InvalidCurrencyError`      |
+| 429     | `UniRate::RateLimitError`            |
+| 503     | `UniRate::APIError` (status 503)     |
+| other   | `UniRate::APIError`                  |
+| network | `UniRate::UnirateError` (base)       |
+
+```ruby
+begin
+  unirate_rate("USD", "EUR")
+rescue UniRate::RateLimitError
+  # back off and retry
+rescue UniRate::UnirateError => e
+  logger.warn("UniRate: #{e.message}")
+end
+```
+
+## Historical / VAT (Pro)
+
+Historical rates are **Pro-gated** and return HTTP 403 on the free tier. They
+are disabled by default; set `:unirate_enable_historical` to `true` (and hold a
+Pro subscription) to call `get_historical_rate` on the client.
+
+## Rate limits
+
+The free tier is rate limited; a 429 raises `UniRate::RateLimitError`. Cache
+responses in your app if you make frequent calls.
+
+## Related clients
+
+Part of the UniRate client family — see
+[github.com/UniRate-API](https://github.com/UniRate-API) for Python, Node,
+Swift, Java, Go, Rust, Ruby, PHP, and .NET clients plus framework integrations.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/lib/sinatra/unirate/client.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "version"
+require_relative "errors"
+
+module UniRate
+  # Stdlib-only HTTP client for the UniRate API (https://unirateapi.com).
+  #
+  # Zero runtime dependencies beyond Ruby's standard library (`net/http`,
+  # `json`, `uri`) — no third-party HTTP gem, so nothing extra to audit in a
+  # Sinatra app's dependency tree.
+  #
+  # Method names and parameter order mirror the canonical UniRate client spec.
+  # Currency and country codes are upcased before being sent.
+  class SinatraClient
+    DEFAULT_BASE_URL = "https://api.unirateapi.com"
+    DEFAULT_TIMEOUT = 30
+
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT, enable_historical: false)
+      @api_key = api_key
+      @base_url = base_url || DEFAULT_BASE_URL
+      @timeout = timeout || DEFAULT_TIMEOUT
+      @enable_historical = enable_historical
+
+      raise AuthenticationError.new("Missing or invalid API key", status: 401) if @api_key.nil? || @api_key.to_s.empty?
+    end
+
+    # GET /api/rates — current rate(s).
+    # Returns a Float when +to+ is given, otherwise a { "EUR" => Float, ... } map.
+    def get_rate(from: "USD", to: nil, format: "json", callback: nil)
+      params = { "from" => up(from) }
+      params["to"] = up(to) if to
+      body = request("/api/rates", params, format: format, callback: callback)
+      return body unless json?(format)
+
+      if to
+        to_f(body.fetch("rate"))
+      else
+        floatify(body.fetch("rates", {}))
+      end
+    end
+
+    # GET /api/convert — current conversion. Returns a Float.
+    def convert(to:, amount: 1, from: "USD", format: "json", callback: nil)
+      params = { "from" => up(from), "to" => up(to), "amount" => amount }
+      body = request("/api/convert", params, format: format, callback: callback)
+      return body unless json?(format)
+
+      to_f(body.fetch("result"))
+    end
+
+    # GET /api/currencies — supported currency codes. Returns an Array of String.
+    def get_supported_currencies(format: "json", callback: nil)
+      body = request("/api/currencies", {}, format: format, callback: callback)
+      return body unless json?(format)
+
+      Array(body.fetch("currencies", []))
+    end
+
+    # GET /api/vat/rates — VAT rates. Returns the whole map keyed by country when
+    # +country+ is nil, otherwise the single-country vat_data hash.
+    def get_vat_rates(country: nil, format: "json", callback: nil)
+      params = {}
+      params["country"] = up(country) if country
+      body = request("/api/vat/rates", params, format: format, callback: callback)
+      return body unless json?(format)
+
+      country ? body.fetch("vat_data") : body.fetch("vat_rates")
+    end
+
+    # GET /api/historical/rates — Pro-gated (403 on free tier). Guarded by the
+    # `enable_historical` flag so a free-tier app doesn't hit it by accident.
+    # Returns a Float or a { code => Float } map depending on args.
+    def get_historical_rate(date:, amount: 1, from: "USD", to: nil, format: "json", callback: nil)
+      ensure_historical_enabled!
+      params = { "date" => date, "from" => up(from), "amount" => amount }
+      params["to"] = up(to) if to
+      body = request("/api/historical/rates", params, format: format, callback: callback)
+      return body unless json?(format)
+
+      parse_historical(body, to: to)
+    end
+
+    private
+
+    def ensure_historical_enabled!
+      return if @enable_historical
+
+      raise APIError.new(
+        "Historical endpoints are Pro-gated and disabled; set :unirate_enable_historical to true to use them",
+        status: 403
+      )
+    end
+
+    def parse_historical(body, to:)
+      if to
+        body.key?("result") ? to_f(body["result"]) : to_f(body.fetch("rate"))
+      else
+        floatify(body.fetch(body.key?("results") ? "results" : "rates", {}))
+      end
+    end
+
+    def request(path, params, format:, callback:)
+      uri = build_uri(path, params, format: format, callback: callback)
+      req = Net::HTTP::Get.new(uri)
+      req["Accept"] = "application/json"
+      req["User-Agent"] = "unirate-sinatra/#{SinatraUniRate::VERSION}"
+      handle(perform(uri, req), format: format)
+    end
+
+    def build_uri(path, params, format:, callback:)
+      uri = URI.parse(@base_url)
+      uri.path = path
+      query = params.merge("api_key" => @api_key)
+      query["format"] = format if format && format != "json"
+      query["callback"] = callback if callback
+      uri.query = URI.encode_www_form(query)
+      uri
+    end
+
+    def perform(uri, req)
+      Net::HTTP.start(uri.hostname, uri.port,
+                      use_ssl: uri.scheme == "https",
+                      open_timeout: @timeout,
+                      read_timeout: @timeout) { |http| http.request(req) }
+    rescue StandardError => e
+      raise UnirateError, "Network error talking to UniRate: #{e.message}"
+    end
+
+    def handle(response, format:)
+      status = response.code.to_i
+      raise_for_status(status, response.body) unless (200..299).cover?(status)
+
+      return response.body.to_s unless json?(format)
+
+      JSON.parse(response.body.to_s)
+    rescue JSON::ParserError => e
+      raise UnirateError, "Failed to parse UniRate response: #{e.message}"
+    end
+
+    def raise_for_status(status, body)
+      case status
+      when 400 then raise InvalidDateError.new("Invalid request parameters", status: 400)
+      when 401 then raise AuthenticationError.new("Missing or invalid API key", status: 401)
+      when 403 then raise APIError.new("Endpoint requires a Pro subscription", status: 403)
+      when 404 then raise InvalidCurrencyError.new("Currency not found or no data available", status: 404)
+      when 429 then raise RateLimitError.new("Rate limit exceeded", status: 429)
+      when 503 then raise APIError.new("Service unavailable", status: 503)
+      else raise APIError.new("UniRate API error (HTTP #{status}): #{body}", status: status)
+      end
+    end
+
+    def json?(format)
+      format.nil? || format == "json"
+    end
+
+    def up(value)
+      value.to_s.upcase
+    end
+
+    def to_f(value)
+      Float(value)
+    end
+
+    def floatify(hash)
+      hash.each_with_object({}) { |(code, value), out| out[code.to_s.upcase] = to_f(value) }
+    end
+  end
+end

data/lib/sinatra/unirate/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module UniRate
+  # Base class for every UniRate-specific failure. Network/transport problems
+  # are wrapped in this; the typed subclasses below carry the HTTP semantics.
+  class UnirateError < StandardError
+    # HTTP status code that produced the error, when one is available.
+    attr_reader :status
+
+    def initialize(message = nil, status: nil)
+      @status = status
+      super(message)
+    end
+  end
+
+  # 400 — malformed request parameters (e.g. a bad historical date).
+  class InvalidDateError < UnirateError; end
+
+  # 401 — missing or invalid API key.
+  class AuthenticationError < UnirateError; end
+
+  # 404 — currency not found or no data available.
+  class InvalidCurrencyError < UnirateError; end
+
+  # 429 — rate limit exceeded.
+  class RateLimitError < UnirateError; end
+
+  # 403 (Pro-gated endpoint on a free tier), 503, or any other non-2xx that
+  # doesn't map to a more specific type. Carries the HTTP status.
+  class APIError < UnirateError; end
+end

data/lib/sinatra/unirate/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Standalone top-level module holding only the version constant. Kept
+# deliberately free of any Sinatra-class reopening: the gemspec
+# `require_relative`s this file at build time, *before* the runtime
+# dependencies (sinatra) are installed. Opening a module that later collides
+# with a Sinatra-defined class/module would risk a "superclass mismatch"
+# TypeError during `gem build`, so the version lives on its own here.
+module SinatraUniRate
+  VERSION = "0.1.0"
+end

data/lib/sinatra/unirate.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+
+require_relative "unirate/version"
+require_relative "unirate/errors"
+require_relative "unirate/client"
+
+# Reopened only to define the UniRate extension below; Sinatra itself is
+# provided by the `sinatra` gem.
+module Sinatra
+  # Sinatra extension wrapping the UniRate API (https://unirateapi.com) for free
+  # currency exchange rates, conversion, supported-currency listings, and VAT
+  # rates.
+  #
+  # Register it in a classic app:
+  #
+  #   require "sinatra"
+  #   require "sinatra/unirate"
+  #   set :unirate_api_key, ENV.fetch("UNIRATE_API_KEY")
+  #
+  #   get("/eur") { unirate_convert(100, "USD", "EUR").to_s }
+  #
+  # ...or a modular app:
+  #
+  #   require "sinatra/base"
+  #   require "sinatra/unirate"
+  #
+  #   class MyApp < Sinatra::Base
+  #     register Sinatra::UniRate
+  #     set :unirate_api_key, ENV.fetch("UNIRATE_API_KEY")
+  #     get("/eur") { unirate_convert(100, "USD", "EUR").to_s }
+  #   end
+  #
+  # Configuration is expressed through Sinatra settings:
+  #
+  #   set :unirate_api_key,           "..."                        # falls back to ENV["UNIRATE_API_KEY"]
+  #   set :unirate_base_url,          "https://api.unirateapi.com"
+  #   set :unirate_timeout,           30
+  #   set :unirate_default_currency,  "USD"
+  #   set :unirate_enable_historical, false                        # Pro-gated; off by default
+  #   set :unirate_mount_routes,      false                        # add /unirate/* JSON proxy routes
+  #
+  module UniRate
+    # Helpers mixed into every route/view when the extension is registered. Each
+    # helper builds a short-lived {SinatraClient} from the app's settings.
+    module Helpers
+      # A {SinatraClient} built from the current app settings. A fresh instance
+      # is returned each call so `set :unirate_*` changes are always picked up.
+      def unirate_client
+        Sinatra::UniRate.client_for(settings)
+      end
+
+      # GET /api/rates. Returns a Float when +to+ is given, else a code=>Float
+      # map. +from+ defaults to the app's :unirate_default_currency setting.
+      def unirate_rate(from = nil, to = nil)
+        from ||= settings.unirate_default_currency
+        unirate_client.get_rate(from: from, to: to)
+      end
+
+      # Convert +amount+ from +from+ to +to+ (a Float). +from+ defaults to the
+      # app's :unirate_default_currency setting.
+      def unirate_convert(amount, from = nil, to = nil)
+        from ||= settings.unirate_default_currency
+        unirate_client.convert(to: to, amount: amount, from: from)
+      end
+
+      # GET /api/currencies. Returns an Array of currency-code strings.
+      def unirate_currencies
+        unirate_client.get_supported_currencies
+      end
+
+      # GET /api/vat/rates. Returns the whole country map when +country+ is nil,
+      # otherwise the single-country vat_data hash.
+      def unirate_vat(country = nil)
+        unirate_client.get_vat_rates(country: country)
+      end
+
+      # Shared wrapper for the mounted JSON proxy routes. Falls through to a 404
+      # unless :unirate_mount_routes is enabled, renders JSON on success, and
+      # maps a typed UniRate error to its HTTP status. Not intended for direct
+      # use in host-app routes.
+      def unirate_proxy
+        pass unless settings.unirate_mount_routes
+        content_type :json
+        yield.to_json
+      rescue ::UniRate::UnirateError => e
+        halt(e.status || 502, { error: e.message }.to_json)
+      end
+    end
+
+    class << self
+      # Builds a {SinatraClient} from a Sinatra settings object. The API key
+      # falls back to ENV["UNIRATE_API_KEY"] when the setting is unset/blank so a
+      # secret never has to be committed to the host app.
+      def client_for(settings)
+        key = settings.unirate_api_key
+        key = ENV.fetch("UNIRATE_API_KEY", nil) if key.nil? || key.to_s.empty?
+
+        ::UniRate::SinatraClient.new(
+          api_key: key,
+          base_url: settings.unirate_base_url,
+          timeout: settings.unirate_timeout,
+          enable_historical: settings.unirate_enable_historical
+        )
+      end
+
+      # Sinatra registration hook. Sets default settings, mixes in the helpers,
+      # and — when :unirate_mount_routes is on — adds the JSON proxy routes.
+      def registered(app)
+        apply_defaults(app)
+        app.helpers(Helpers)
+        mount_routes(app)
+      end
+
+      private
+
+      def apply_defaults(app)
+        app.set :unirate_api_key, nil unless app.respond_to?(:unirate_api_key)
+        app.set :unirate_base_url, ::UniRate::SinatraClient::DEFAULT_BASE_URL unless app.respond_to?(:unirate_base_url)
+        app.set :unirate_timeout, ::UniRate::SinatraClient::DEFAULT_TIMEOUT unless app.respond_to?(:unirate_timeout)
+        app.set :unirate_default_currency, "USD" unless app.respond_to?(:unirate_default_currency)
+        app.set :unirate_enable_historical, false unless app.respond_to?(:unirate_enable_historical)
+        app.set :unirate_mount_routes, false unless app.respond_to?(:unirate_mount_routes)
+      end
+
+      # Defines /unirate/rate, /unirate/convert, and /unirate/currencies JSON
+      # proxy routes. They are always declared at registration, but `pass` (fall
+      # through to a 404) unless :unirate_mount_routes is enabled — this lets the
+      # host app flip the setting *after* `register` (Sinatra evaluates route
+      # bodies per-request, not at registration). The API key never leaves the
+      # server; typed UniRate errors map back to their HTTP status.
+      def mount_routes(app)
+        app.get("/unirate/rate") do
+          unirate_proxy { { rate: unirate_client.get_rate(from: params["from"] || "USD", to: params["to"]) } }
+        end
+
+        app.get("/unirate/convert") do
+          unirate_proxy do
+            result = unirate_client.convert(
+              to: params["to"], amount: Float(params["amount"] || 1), from: params["from"] || "USD"
+            )
+            { result: result }
+          end
+        end
+
+        app.get("/unirate/currencies") do
+          unirate_proxy { { currencies: unirate_client.get_supported_currencies } }
+        end
+      end
+    end
+  end
+
+  # Make the extension available to classic-style apps (`require "sinatra"`),
+  # which register into the top-level Sinatra::Application.
+  register UniRate if respond_to?(:register)
+end

data/lib/sinatra-unirate.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Alias entry point so `require "sinatra-unirate"` (matching the gem name) works
+# as well as the idiomatic `require "sinatra/unirate"`.
+require_relative "sinatra/unirate"

data/sinatra-unirate.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sinatra/unirate/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinatra-unirate"
+  spec.version       = SinatraUniRate::VERSION
+  spec.authors       = ["Unirate Team"]
+  spec.email         = ["admin@unirateapi.com"]
+
+  spec.summary       = "Sinatra extension for the UniRate API — currency exchange rates, conversion, and VAT."
+  spec.description   = "A Sinatra extension wrapping the UniRate API " \
+                       "(https://unirateapi.com) — free currency exchange rates, " \
+                       "conversion, supported-currency listings, and VAT rates. " \
+                       "Registers via `register Sinatra::UniRate` in classic or " \
+                       "modular apps, exposes settings-based configuration, route/view " \
+                       "helpers (unirate_rate, unirate_convert, unirate_currencies, " \
+                       "unirate_vat), an optional JSON proxy mount, and a stdlib-only " \
+                       "client with full error mapping. Zero runtime dependencies " \
+                       "beyond Sinatra."
+  spec.homepage      = "https://github.com/UniRate-API/sinatra-unirate"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "bug_tracker_uri" => "#{spec.homepage}/issues",
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    "documentation_uri" => "https://unirateapi.com",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "sinatra-unirate.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sinatra", ">= 2.0"
+
+  spec.add_development_dependency "rack-test", ">= 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "rubocop", "~> 1.60"
+  spec.add_development_dependency "webmock", "~> 3.19"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-unirate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Unirate Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+description: A Sinatra extension wrapping the UniRate API (https://unirateapi.com)
+  — free currency exchange rates, conversion, supported-currency listings, and VAT
+  rates. Registers via `register Sinatra::UniRate` in classic or modular apps, exposes
+  settings-based configuration, route/view helpers (unirate_rate, unirate_convert,
+  unirate_currencies, unirate_vat), an optional JSON proxy mount, and a stdlib-only
+  client with full error mapping. Zero runtime dependencies beyond Sinatra.
+email:
+- admin@unirateapi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/sinatra-unirate.rb
+- lib/sinatra/unirate.rb
+- lib/sinatra/unirate/client.rb
+- lib/sinatra/unirate/errors.rb
+- lib/sinatra/unirate/version.rb
+- sinatra-unirate.gemspec
+homepage: https://github.com/UniRate-API/sinatra-unirate
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/UniRate-API/sinatra-unirate
+  source_code_uri: https://github.com/UniRate-API/sinatra-unirate
+  bug_tracker_uri: https://github.com/UniRate-API/sinatra-unirate/issues
+  changelog_uri: https://github.com/UniRate-API/sinatra-unirate/blob/main/CHANGELOG.md
+  documentation_uri: https://unirateapi.com
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Sinatra extension for the UniRate API — currency exchange rates, conversion,
+  and VAT.
+test_files: []