unirate-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d669d6f75495a08bc375cdc3dbf1f687122b08172cf46fe8ce08e91e3cd9f85
+  data.tar.gz: 1d05ad12bacfcfb5c0bd8feadebcb645049c875d36329d0f878b8b70a7e1d98c
+SHA512:
+  metadata.gz: ad00bf1334a0073950d54512c3d80330ac672f368bcefbe79410aa109fc0aad785424b1eb9770095af9e545bb83fd2bd67a6b2af3c87da180cceb1b1cf3bb2a6
+  data.tar.gz: '0879332571fb8ecab13ff779e9e152ac33809a212e6f2699bfcd951f926a1b055989d1a3d068d758b5994b73d86ded3be4d511611b27f7c4e12f155b0624b5c4'

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# 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.
+- `UniRateRails::Engine` — a mountable, isolated Rails engine.
+- `UniRateRails.configure { |c| ... }` process-wide configuration with an
+  `UNIRATE_API_KEY` env-var fallback for the API key.
+- `UniRateRails::Client` — 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.
+- ActionView helpers `unirate_rate` and `unirate_convert`, mixed into every
+  view render by the engine.
+- Mountable JSON proxy controller: `GET rate`, `GET convert`, `GET currencies`.
+- 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,144 @@
+# unirate-rails
+
+A mountable [Rails engine](https://guides.rubyonrails.org/engines.html) for the
+[UniRate API](https://unirateapi.com) — free, real-time currency exchange
+rates, conversion, supported-currency listings, and VAT rates, wired straight
+into your Rails app.
+
+- `UniRateRails.configure { |c| c.api_key = ... }` block-style setup, or read
+  the key from `UNIRATE_API_KEY` automatically
+- ActionView helpers — `unirate_rate` and `unirate_convert` — mixed into every
+  view render by the engine
+- A mountable JSON proxy controller so your frontend never sees the API key
+- `UniRateRails.client` — a plain client for controllers and service objects
+- 170+ currencies (fiat + crypto) via UniRate
+- Free tier, no credit card required
+- **Zero runtime dependencies beyond Rails** (pure stdlib `net/http` + `json`)
+
+> **Affiliation:** this engine 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+
+- Rails (railties) 6.1+
+
+## Installation
+
+```ruby
+# Gemfile
+gem "unirate-rails"
+```
+
+```bash
+bundle install
+```
+
+## Quick start
+
+```ruby
+# config/initializers/unirate.rb
+UniRateRails.configure do |c|
+  c.api_key           = ENV.fetch("UNIRATE_API_KEY") # or leave nil to read the env var lazily
+  c.default_currency  = "USD"
+  c.enable_historical = false # Pro-gated; leave off on the free tier
+end
+```
+
+Get a free API key at [unirateapi.com](https://unirateapi.com).
+
+### View helpers
+
+```erb
+<p>1 USD = <%= unirate_rate("USD", "EUR") %> EUR</p>
+<p>$100 = <%= unirate_convert(100, "USD", "EUR") %> EUR</p>
+```
+
+Both helpers return `nil` (instead of raising) on any UniRate error, so a
+transient API hiccup never breaks a page render.
+
+### JSON proxy endpoints
+
+Mount the engine to expose server-side proxy endpoints — the API key stays on
+the server:
+
+```ruby
+# config/routes.rb
+mount UniRateRails::Engine => "/unirate"
+```
+
+```
+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", ...] }
+```
+
+### Direct client use
+
+```ruby
+client = UniRateRails.client
+
+client.get_rate(from: "USD", to: "EUR")          # => 0.92
+client.get_rate(from: "USD")                     # => { "EUR" => 0.92, "GBP" => 0.79, ... }
+client.convert(to: "EUR", amount: 100)           # => 92.5
+client.get_supported_currencies                  # => ["USD", "EUR", "GBP", ...]
+client.get_vat_rates(country: "DE")              # => { "country_code" => "DE", "vat_rate" => 19.0 }
+```
+
+## Configuration
+
+| Option              | Default                         | Description                                          |
+|---------------------|---------------------------------|------------------------------------------------------|
+| `api_key`           | `ENV["UNIRATE_API_KEY"]`        | Your UniRate API key.                                |
+| `base_url`          | `https://api.unirateapi.com`    | API base URL.                                        |
+| `timeout`           | `30`                            | HTTP open/read timeout in seconds.                   |
+| `default_currency`  | `"USD"`                         | Base used by the one-arg view helpers.               |
+| `enable_historical` | `false`                         | Enable the Pro-gated historical endpoint (see below).|
+
+## Error handling
+
+Every failure raises a subclass of `UniRateRails::UnirateError`:
+
+| HTTP  | Exception                              |
+|-------|----------------------------------------|
+| 400   | `UniRateRails::InvalidDateError`       |
+| 401   | `UniRateRails::AuthenticationError`    |
+| 403   | `UniRateRails::APIError` (status 403)  |
+| 404   | `UniRateRails::InvalidCurrencyError`   |
+| 429   | `UniRateRails::RateLimitError`         |
+| 503   | `UniRateRails::APIError` (status 503)  |
+| other | `UniRateRails::APIError`               |
+| network | `UniRateRails::UnirateError` (base)  |
+
+```ruby
+begin
+  UniRateRails.client.get_rate(from: "USD", to: "EUR")
+rescue UniRateRails::RateLimitError
+  # back off and retry
+rescue UniRateRails::UnirateError => e
+  Rails.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 `config.enable_historical = true` (and hold a Pro
+subscription) to call `get_historical_rate`.
+
+## Rate limits
+
+The free tier is rate limited; a 429 raises `UniRateRails::RateLimitError`.
+Cache responses in your app (e.g. `Rails.cache`) 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/app/controllers/unirate_rails/rates_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module UniRateRails
+  # JSON proxy endpoints for the UniRate API. Mount the engine to expose them:
+  #
+  #   mount UniRateRails::Engine => "/unirate"
+  #
+  # then:
+  #   GET /unirate/rate?from=USD&to=EUR
+  #   GET /unirate/convert?from=USD&to=EUR&amount=100
+  #   GET /unirate/currencies
+  #
+  # The API key never leaves the server — it lives in the engine configuration,
+  # not in the browser. Typed UniRate errors are mapped back to sensible HTTP
+  # statuses.
+  class RatesController < ActionController::Base
+    rescue_from UniRateRails::UnirateError, with: :render_unirate_error
+
+    def rate
+      render json: { rate: client.get_rate(from: params[:from] || "USD", to: params[:to]) }
+    end
+
+    def convert
+      result = client.convert(
+        to: params[:to],
+        amount: Float(params[:amount] || 1),
+        from: params[:from] || "USD"
+      )
+      render json: { result: result }
+    end
+
+    def currencies
+      render json: { currencies: client.get_supported_currencies }
+    end
+
+    private
+
+    def client
+      UniRateRails.client
+    end
+
+    def render_unirate_error(error)
+      status = error.respond_to?(:status) && error.status ? error.status : 502
+      render json: { error: error.message }, status: status
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+UniRateRails::Engine.routes.draw do
+  get "rate", to: "rates#rate"
+  get "convert", to: "rates#convert"
+  get "currencies", to: "rates#currencies"
+end

data/lib/unirate-rails.rb

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

data/lib/unirate_rails/client.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module UniRateRails
+  # 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
+  # Rails 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 Client
+    def initialize(api_key: nil, base_url: nil, timeout: nil)
+      config = UniRateRails.configuration
+      @api_key = api_key || config.api_key
+      @base_url = base_url || config.base_url
+      @timeout = timeout || config.timeout
+
+      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` config 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 UniRateRails.configuration.enable_historical
+
+      raise APIError.new(
+        "Historical endpoints are Pro-gated and disabled; set config.enable_historical = 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-rails/#{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/unirate_rails/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module UniRateRails
+  # Process-wide configuration, populated in an initializer via
+  # {UniRateRails.configure}. The API key falls back to the `UNIRATE_API_KEY`
+  # environment variable so a secret never has to be committed to the host app.
+  #
+  #   # config/initializers/unirate.rb
+  #   UniRateRails.configure do |c|
+  #     c.api_key          = ENV.fetch("UNIRATE_API_KEY")
+  #     c.default_currency = "USD"
+  #     c.enable_historical = false
+  #   end
+  class Configuration
+    DEFAULT_BASE_URL = "https://api.unirateapi.com"
+    DEFAULT_TIMEOUT = 30
+
+    attr_accessor :base_url, :timeout, :default_currency, :enable_historical
+    attr_writer :api_key
+
+    def initialize
+      @api_key = nil
+      @base_url = DEFAULT_BASE_URL
+      @timeout = DEFAULT_TIMEOUT
+      @default_currency = "USD"
+      # Historical endpoints are Pro-gated (HTTP 403 on the free tier). Off by
+      # default so a free-tier app never surfaces a confusing 403; flip it on
+      # once the account has a Pro subscription.
+      @enable_historical = false
+    end
+
+    # Resolves from the explicit setter first, then the environment.
+    def api_key
+      return @api_key unless @api_key.nil? || @api_key.to_s.empty?
+
+      ENV.fetch("UNIRATE_API_KEY", nil)
+    end
+  end
+end

data/lib/unirate_rails/engine.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+require "action_dispatch"
+
+module UniRateRails
+  # Isolated, mountable Rails engine. Wiring it up does three things:
+  #
+  # 1. Namespaces the engine so its routes/controllers don't collide with the
+  #    host app.
+  # 2. Mixes {UniRateRails::Helper} into every ActionView render, exposing the
+  #    `unirate_rate` / `unirate_convert` view helpers.
+  #
+  # Mount the JSON proxy controller from the host app's routes if you want a
+  # ready-made endpoint:
+  #
+  #   # config/routes.rb
+  #   mount UniRateRails::Engine => "/unirate"
+  class Engine < ::Rails::Engine
+    isolate_namespace UniRateRails
+
+    initializer "unirate_rails.action_view" do
+      ActiveSupport.on_load(:action_view) do
+        include UniRateRails::Helper
+      end
+    end
+  end
+end

data/lib/unirate_rails/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module UniRateRails
+  # 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/unirate_rails/helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module UniRateRails
+  # View helpers mixed into `ActionView::Base` by {UniRateRails::Engine} so
+  # templates can look up rates and conversions inline. Each helper builds a
+  # short-lived {Client} from the process configuration.
+  #
+  #   <%= unirate_rate("USD", "EUR") %>          => 0.92
+  #   <%= unirate_convert(100, "USD", "EUR") %>  => 92.5
+  module Helper
+    # Current rate from +from+ to +to+ (a Float), or nil on any UniRate error
+    # so a rate hiccup never raises inside a view render.
+    def unirate_rate(from = nil, to = nil)
+      from ||= UniRateRails.configuration.default_currency
+      UniRateRails.client.get_rate(from: from, to: to)
+    rescue UniRateRails::UnirateError
+      nil
+    end
+
+    # Convert +amount+ from +from+ to +to+ (a Float), or nil on any UniRate
+    # error.
+    def unirate_convert(amount, from = nil, to = nil)
+      from ||= UniRateRails.configuration.default_currency
+      UniRateRails.client.convert(to: to, amount: amount, from: from)
+    rescue UniRateRails::UnirateError
+      nil
+    end
+  end
+end

data/lib/unirate_rails/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Standalone top-level module holding only the version constant. Kept
+# deliberately free of any `Rails::Engine` (or other runtime-class) reopening:
+# the gemspec `require_relative`s this file at build time, *before* the runtime
+# dependencies (railties) are installed. Opening a module that later becomes a
+# subclass of something Rails-defined would blow up with a "superclass
+# mismatch" TypeError during `gem build`.
+module UniRateRails
+  VERSION = "0.1.0"
+end

data/lib/unirate_rails.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "unirate_rails/version"
+require_relative "unirate_rails/errors"
+require_relative "unirate_rails/configuration"
+require_relative "unirate_rails/client"
+require_relative "unirate_rails/helper"
+
+# UniRate for Rails — a mountable Rails engine wrapping the UniRate API
+# (https://unirateapi.com) for free currency exchange rates, conversion,
+# supported-currency listings, and VAT rates.
+#
+#   UniRateRails.configure { |c| c.api_key = ENV.fetch("UNIRATE_API_KEY") }
+#   UniRateRails.client.get_rate(from: "USD", to: "EUR") # => 0.92
+module UniRateRails
+  class << self
+    # The process-wide {Configuration}. Lazily created on first access.
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the configuration for block-style setup, typically from a Rails
+    # initializer.
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    # Resets configuration to defaults (mainly useful in tests).
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    # A {Client} built from the current configuration. A fresh instance is
+    # returned each call so config changes are always picked up.
+    def client
+      Client.new
+    end
+  end
+end
+
+# The engine pulls in railties, so only load it when Rails is present. This
+# keeps the core client usable outside a Rails app (and keeps `gem build`,
+# which runs before deps install, from needing Rails on the load path).
+require_relative "unirate_rails/engine" if defined?(Rails::Engine)

data/unirate-rails.gemspec

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "unirate_rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "unirate-rails"
+  spec.version       = UniRateRails::VERSION
+  spec.authors       = ["Unirate Team"]
+  spec.email         = ["admin@unirateapi.com"]
+
+  spec.summary       = "Rails engine for the UniRate API — currency exchange rates, conversion, and VAT."
+  spec.description   = "A mountable Rails engine wrapping the UniRate API " \
+                       "(https://unirateapi.com) — free currency exchange rates, " \
+                       "conversion, supported-currency listings, and VAT rates. " \
+                       "Ships a configurable client, ActionView helpers " \
+                       "(unirate_rate, unirate_convert), and a JSON proxy " \
+                       "controller. Zero runtime dependencies beyond Rails."
+  spec.homepage      = "https://github.com/UniRate-API/unirate-rails"
+  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",
+    "app/**/*.rb",
+    "config/**/*.rb",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "unirate-rails.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties", ">= 6.1"
+
+  spec.add_development_dependency "actionpack", ">= 6.1"
+  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,151 @@
+--- !ruby/object:Gem::Specification
+name: unirate-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Unirate Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !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 mountable Rails engine wrapping the UniRate API (https://unirateapi.com)
+  — free currency exchange rates, conversion, supported-currency listings, and VAT
+  rates. Ships a configurable client, ActionView helpers (unirate_rate, unirate_convert),
+  and a JSON proxy controller. Zero runtime dependencies beyond Rails.
+email:
+- admin@unirateapi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- app/controllers/unirate_rails/rates_controller.rb
+- config/routes.rb
+- lib/unirate-rails.rb
+- lib/unirate_rails.rb
+- lib/unirate_rails/client.rb
+- lib/unirate_rails/configuration.rb
+- lib/unirate_rails/engine.rb
+- lib/unirate_rails/errors.rb
+- lib/unirate_rails/helper.rb
+- lib/unirate_rails/version.rb
+- unirate-rails.gemspec
+homepage: https://github.com/UniRate-API/unirate-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/UniRate-API/unirate-rails
+  source_code_uri: https://github.com/UniRate-API/unirate-rails
+  bug_tracker_uri: https://github.com/UniRate-API/unirate-rails/issues
+  changelog_uri: https://github.com/UniRate-API/unirate-rails/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: Rails engine for the UniRate API — currency exchange rates, conversion, and
+  VAT.
+test_files: []