hitch-rails 0.2.0 → 0.4.0

data/lib/hitch/doctor.rb

@@ -26,6 +26,10 @@ module Hitch
     REMEDIES = {
       "unsupported" => "Match Hitch's supported window, or upgrade Hitch.",
       "invalid" => "Run the failing setting's validation directly: Hitch.configuration.validate!",
+      "dynamic_client_registration_rate_store_invalid" =>
+        "Configure config.dynamic_client_registration_rate_store with a shared cache store whose two increments return 1 then 2.",
+      "device_authorization_rate_store_invalid" =>
+        "Configure config.device_authorization_rate_store with a shared cache store whose two increments return 1 then 2.",
       "unresolvable" => "Boot the app to see which tool failed; " \
         "Hitch.configuration.validate! does not build the registry and will report success.",
       "mismatch" => "resource_uri must equal the URI clients send as `resource`, byte for byte.",
@@ -43,6 +47,15 @@ module Hitch
         "or set mcp.rate_limit_store explicitly.",
       "probe_error" => "The check itself could not run; HITCH_DOCTOR_FORMAT=json names the error class."
     }.freeze
+    ConfigurationStoreError = Class.new(StandardError) do
+      attr_reader :setting, :store_class
+
+      def initialize(setting:, store:)
+        @setting = setting.to_s.freeze
+        @store_class = store.class.name.to_s.freeze
+        super("#{@setting} is unusable in production")
+      end
+    end
     Check = Data.define(:id, :status, :code, :summary, :details) do
       def initialize(id:, status:, code:, summary:, details: {})
         super(
@@ -85,11 +98,18 @@ module Hitch
       end
     end
 
+    # Rails host authorization answers a rejected Host with its HTML 403 page,
+    # which the discovery probe's JSON parser reported as a JSON::ParserError:
+    # one blocked host, two alarms, and the louder one naming a bug that does
+    # not exist. The middleware records the rejection on the env it was handed.
+    HostBlocked = Class.new(StandardError)
+
     class System
       REQUIRED_TABLES = %w[
         hitch_access_tokens
         hitch_clients
         hitch_client_redirect_uris
+        hitch_device_grants
       ].freeze
 
       def versions
@@ -108,31 +128,46 @@ module Hitch
       def validate_configuration!
         configuration = Hitch.configuration
         configuration.validate!
-        if Rails.env.production? && configuration.dynamic_client_registration_enabled
-          store = configuration.dynamic_client_registration_rate_store
-          Hitch::RateLimitStore.assert_shared!(
-            store, setting: Hitch::DynamicRegistrationRateLimit::SETTING
+        return true unless Rails.env.production?
+
+        if configuration.dynamic_client_registration_enabled
+          check_production_rate_store!(
+            configuration.dynamic_client_registration_rate_store,
+            Hitch::DynamicRegistrationRateLimit::SETTING
+          )
+        end
+        if configuration.device_authorization_enabled
+          check_production_rate_store!(
+            configuration.device_authorization_rate_store,
+            Hitch::DeviceAuthorizationRateLimit::SETTING
           )
-          probe_registration_store!(store)
         end
         true
       end
 
-      # A dedicated-but-unreachable registration store passes the class check
-      # while every production registration 503s; drive it like the admission
-      # probe does. Registration refuses on an uncountable store, so this
-      # mirrors the request path rather than adding a stricter one.
-      def probe_registration_store!(store)
+      def check_production_rate_store!(store, setting)
+        Hitch::RateLimitStore.assert_shared!(store, setting: setting)
+        probe_rate_store!(store, setting)
+      rescue NotImplementedError, StandardError => error
+        raise ConfigurationStoreError.new(setting:, store:), cause: error
+      end
+
+      # A dedicated-but-unreachable store passes the class check while every
+      # production request it guards 503s; drive it like the admission probe
+      # does. Two increments on the same key must return the values the
+      # limiter's comparison depends on, not merely some Integer.
+      def probe_rate_store!(store, setting)
         key = "hitch:doctor:v1:#{SecureRandom.hex(16)}"
-        count = begin
-          store.increment(key, 1, expires_in: 5)
-        rescue NotImplementedError
-          nil
+        counts = 2.times.map do
+          begin
+            store.increment(key, 1, expires_in: 5)
+          rescue NotImplementedError
+            nil
+          end
         end
-        return true if count.is_a?(Integer)
+        return true if counts == [ 1, 2 ]
 
-        raise Hitch::DynamicRegistrationRateLimit::Unavailable,
-          "#{Hitch::DynamicRegistrationRateLimit::SETTING} cannot count registration attempts"
+        raise Hitch::RateLimitStore::Unavailable, "#{setting} cannot count attempts"
       ensure
         begin
           store&.delete(key)
@@ -312,6 +347,8 @@ module Hitch
           "HTTPS" => ("on" if resource.scheme == "https")
         ).compact
         status, _headers, body = Rails.application.call(environment)
+        raise HostBlocked if environment["action_dispatch.blocked_hosts"]&.any?
+
         bytes = +""
         body.each do |part|
           bytes << part.to_s
@@ -473,6 +510,21 @@ module Hitch
       code = runtime ? "valid_full_runtime" : "valid_auth_only"
       summary = runtime ? "OAuth and MCP runtime configuration is valid" : "OAuth configuration is valid; MCP runtime is disabled"
       pass("configuration", code, summary, "environment" => system.environment_name, "runtime_enabled" => runtime)
+    rescue ConfigurationStoreError => error
+      code, summary = case error.setting
+      when "config.dynamic_client_registration_rate_store"
+        [ "dynamic_client_registration_rate_store_invalid", "Dynamic client registration rate store is unusable in production" ]
+      when "config.device_authorization_rate_store"
+        [ "device_authorization_rate_store_invalid", "Device authorization rate store is unusable in production" ]
+      end
+      fail_check(
+        "configuration",
+        code,
+        summary,
+        "environment" => system.environment_name,
+        "setting" => error.setting,
+        "store_class" => error.store_class
+      )
     rescue StandardError => error
       environment = begin
         system.environment_name
@@ -505,6 +557,12 @@ module Hitch
       return pass("resource_discovery", "coherent", "Canonical resource and discovery documents agree", details) if coherent
 
       fail_check("resource_discovery", "mismatch", "Canonical resource and discovery documents do not agree", details)
+    rescue HostBlocked
+      skip(
+        "resource_discovery",
+        "host_blocked",
+        "Discovery probe cannot run while Rails host authorization blocks the canonical host"
+      )
     rescue StandardError => error
       probe_failure("resource_discovery", error)
     end
@@ -642,6 +700,6 @@ module Hitch
       fail_check(id, "probe_error", "The #{id.tr('_', ' ')} diagnostic could not complete", "error_class" => error.class.name)
     end
 
-    private_constant :Check, :Report, :System
+    private_constant :Check, :Report, :System, :HostBlocked
   end
 end

data/lib/hitch/dynamic_registration_rate_limit.rb

@@ -1,75 +1,23 @@
 # frozen_string_literal: true
 
-require "ipaddr"
-require "openssl"
-
 module Hitch
   # Private fixed-window guard for unauthenticated client registration. It
-  # counts through the host application's own cache store; see
-  # Hitch::RateLimitStore.
+  # counts through the host application's own cache store; the fail-closed
+  # policy lives in Hitch::RateLimitStore.
   class DynamicRegistrationRateLimit
-    class Unavailable < StandardError; end
-
-    class Exceeded < StandardError
-      attr_reader :retry_after
-
-      def initialize(retry_after)
-        @retry_after = retry_after
-        super("dynamic client registration rate limit exceeded")
-      end
-    end
+    Unavailable = Hitch::RateLimitStore::Unavailable
+    Exceeded = Hitch::RateLimitStore::Exceeded
 
     SETTING = "config.dynamic_client_registration_rate_store"
 
-    class << self
-      def check!(remote_ip:)
-        configuration = Hitch.configuration
-        limit = configuration.dynamic_client_registration_limit
-        count = increment(
-          configuration.dynamic_client_registration_rate_store,
-          key_for(remote_ip),
-          limit.fetch(:within)
-        )
-        # A store that cannot count returns nil, the way Rails' :null_store
-        # does. Unlike MCP request admission, which sits behind a bearer token,
-        # registration is unauthenticated: an uncountable store in production
-        # would let anyone create unlimited clients, so refuse rather than
-        # admit. Production also refuses such stores at boot; this is the
-        # second lock on an unauthenticated write.
-        if count.nil?
-          raise Unavailable, "#{SETTING} cannot count registration attempts" if Rails.env.production?
-
-          return true
-        end
-        raise Exceeded, limit.fetch(:within) if count > limit.fetch(:to)
-
-        true
-      end
-
-      private
-
-      def increment(store, key, expires_in)
-        count = store.increment(key, 1, expires_in: expires_in)
-        return if count.nil?
-        raise Unavailable, "DCR rate store returned an invalid count" unless count.is_a?(Integer)
-
-        count
-      rescue Unavailable
-        raise
-      # NotImplementedError (a ScriptError): raised by the base
-      # ActiveSupport::Cache::Store#increment when a store never overrode it.
-      rescue NotImplementedError, StandardError
-        raise Unavailable, "DCR rate store increment failed"
-      end
-
-      def key_for(remote_ip)
-        normalized_ip = IPAddr.new(remote_ip.to_s).to_s
-        secret = Rails.application.secret_key_base.to_s
-        digest = OpenSSL::HMAC.hexdigest("SHA256", secret, normalized_ip)
-        "hitch:dcr:ip:#{digest}"
-      rescue IPAddr::InvalidAddressError
-        raise Unavailable, "DCR request IP could not be normalized"
-      end
+    def self.check!(remote_ip:)
+      configuration = Hitch.configuration
+      RateLimitStore.check!(
+        configuration.dynamic_client_registration_rate_store,
+        RateLimitStore.hmac_key("hitch:dcr:ip:", RateLimitStore.normalize_ip(remote_ip)),
+        configuration.dynamic_client_registration_limit,
+        setting: SETTING
+      )
     end
   end
 end

data/lib/hitch/engine.rb

@@ -28,6 +28,10 @@ module Hitch
 
     # Host apps see the engine's migrations via db:migrate without needing
     # to copy them — the install generator only writes the initializer.
+    #
+    # The corollary is that a shipped migration IS an adopter's migration, so
+    # editing one applies to fresh installs and silently skips every existing
+    # one. Append only; see docs/adr/0005-migration-append-only.md.
     initializer :append_migrations do |app|
       next if app.root.to_s == root.to_s
       # Skipped when ENGINE_ROOT is defined, which means the process was
@@ -95,10 +99,19 @@ module Hitch
 
       next unless Rails.env.production?
 
-      Hitch::RateLimitStore.assert_shared!(
-        configuration.dynamic_client_registration_rate_store,
-        setting: Hitch::DynamicRegistrationRateLimit::SETTING
-      )
+      configuration.validate_dynamic_client_registration_rate_store!
+    end
+
+    initializer "hitch.validate_device_authorization", after: :load_config_initializers do
+      configuration = Hitch.configuration
+      next unless configuration.device_authorization_enabled
+      next if Hitch::Engine.doctor_command?
+      next unless Rails.env.production?
+
+      # The verification quota is what makes short user codes safe, and it
+      # fails closed — so a store that cannot count across processes must
+      # refuse the boot, not every /activate submission.
+      configuration.validate_device_authorization_rate_store!
     end
 
     initializer "hitch.validate_configuration", after: :load_config_initializers do
@@ -147,7 +160,11 @@ module Hitch
         :client_secret_digest,
         :access_token,
         :authorization_code,
-        :token
+        :token,
+        # Both device-flow codes are lookup credentials, and user_code also
+        # rides the verification_uri_complete query string on GET /activate.
+        :device_code,
+        :user_code
       ]
     end
   end

data/lib/hitch/grant_types.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hitch
+  # Which OAuth grants the token endpoint will actually accept right now.
+  #
+  # One source of truth on purpose. Discovery metadata advertising a grant is
+  # a promise a conformant client will act on, so a hardcoded
+  # `grant_types_supported` that drifted from the endpoint's real behaviour
+  # would send clients to a door this server answers with
+  # unsupported_grant_type.
+  module GrantTypes
+    DEVICE_CODE = "urn:ietf:params:oauth:grant-type:device_code"
+
+    module_function
+
+    def supported
+      types = [ "authorization_code" ]
+      types << "refresh_token" if Hitch.configuration.refresh_tokens_enabled
+      types << DEVICE_CODE if Hitch.configuration.device_authorization_enabled
+      types.freeze
+    end
+  end
+end

data/lib/hitch/mcp/configuration.rb

@@ -122,10 +122,13 @@ module Hitch
       # Resolved separately from validate! because the application's cache store
       # is assembled by Rails' own initializers; this runs from to_prepare, once
       # config.cache_store is settled.
+      # The raw setting is passed, not the resolving reader: reading it here
+      # would ask ActionController::Base for the default store during
+      # initialization, which is the premature load this avoids.
       def validate_rate_limit_store!
         return true unless Rails.env.production?
 
-        Hitch::RateLimitStore.assert_shared!(rate_limit_store, setting: SETTING)
+        Hitch::RateLimitStore.assert_shared_at_boot!(@rate_limit_store, setting: SETTING)
       end
 
       # Framework lifecycle, not a host knob: the engine's to_prepare hook

data/lib/hitch/rack_form_guard.rb

@@ -15,9 +15,16 @@ module Hitch
       "hitch/authorizations" => "create",
       "hitch/registrations" => "create",
       "hitch/revocations" => "create",
-      "hitch/tokens" => "create"
+      "hitch/tokens" => "create",
+      "hitch/device_authorizations" => "create",
+      "hitch/activations" => "create"
     }.freeze
-    OAUTH_CANDIDATE_PATH = %r{/(?:oauth)/(?:authorize|register|revoke|token)(?:\.[^/]*)?/?\z}
+    # /activate is anchored to the root: the /oauth/* names are distinctive
+    # enough to probe as suffixes under any mount, but bare "activate" is a
+    # common host member-action name, and the engine's well-known routes
+    # already require a root mount.
+    OAUTH_CANDIDATE_PATH =
+      %r{/oauth/(?:authorize|register|revoke|token|device_authorization)(?:\.[^/]*)?/?\z|\A/+activate(?:\.[^/]*)?/?\z}
 
     def initialize(app, routes: -> { Rails.application.routes })
       @app = app

data/lib/hitch/rate_limit_store.rb

@@ -1,17 +1,88 @@
 # frozen_string_literal: true
 
+require "ipaddr"
+require "openssl"
+
 module Hitch
-  # Both Hitch rate limits — unauthenticated client registration and
-  # authenticated MCP requests — count through the host application's own
-  # ActiveSupport::Cache store, the way ActionController::RateLimiting does.
-  # Neither adds a service to the deployment, and neither asks the host to
-  # implement an interface.
+  # Hitch's rate limits — unauthenticated client registration, the device
+  # authorization flow, and authenticated MCP requests — count through the
+  # host application's own ActiveSupport::Cache store, the way
+  # ActionController::RateLimiting does. Neither adds a service to the
+  # deployment, and neither asks the host to implement an interface.
   module RateLimitStore
+    class Unavailable < StandardError; end
+
+    class Exceeded < StandardError
+      attr_reader :retry_after
+
+      def initialize(retry_after)
+        @retry_after = retry_after
+        super("rate limit exceeded")
+      end
+    end
+
     class << self
       def resolve(configured)
         configured || ActionController::Base.cache_store
       end
 
+      # The fail-closed fixed window every limiter guarding an
+      # unauthenticated or guessable surface applies. A store that cannot
+      # count returns nil, the way Rails' :null_store does; in production
+      # that refuses rather than admits — an uncounted attempt would void
+      # the entropy math these limits are a term in — while development and
+      # test admit, as Rails does. Production also refuses such stores at
+      # boot; this is the second lock.
+      def check!(store, key, limit, setting:)
+        count = begin
+          value = store.increment(key, 1, expires_in: limit.fetch(:within))
+          unless value.nil? || value.is_a?(Integer)
+            raise Unavailable, "#{setting} returned an invalid count"
+          end
+          value
+        rescue Unavailable
+          raise
+        # NotImplementedError (a ScriptError): raised by the base
+        # ActiveSupport::Cache::Store#increment when a store never overrode it.
+        rescue NotImplementedError, StandardError
+          raise Unavailable, "#{setting} increment failed"
+        end
+        if count.nil?
+          raise Unavailable, "#{setting} cannot count attempts" if Rails.env.production?
+
+          return true
+        end
+        raise Exceeded, limit.fetch(:within) if count > limit.fetch(:to)
+
+        true
+      end
+
+      # Counting keys carry an HMAC of the identity, never the identity
+      # itself: a cache store is not a log, and a shared one is readable by
+      # more than this app.
+      def hmac_key(prefix, identity)
+        secret = Rails.application.secret_key_base.to_s
+        "#{prefix}#{OpenSSL::HMAC.hexdigest('SHA256', secret, identity)}"
+      end
+
+      def normalize_ip(remote_ip)
+        IPAddr.new(remote_ip.to_s).to_s
+      rescue IPAddr::InvalidAddressError
+        raise Unavailable, "request IP could not be normalized"
+      end
+
+      # Class name included so two principal models cannot collide on an
+      # integer id; nil when the principal has no id — including a nil
+      # one, or every unidentifiable visitor would share one counting
+      # bucket — which keeps callers honest about an identity they cannot
+      # count.
+      def actor_for(principal)
+        id = principal.id if principal.respond_to?(:id)
+        return nil if id.nil?
+
+        "#{principal.class.name}:#{id}"
+      end
+
       def validate!(store, setting:)
         return store if store.nil? || store.respond_to?(:increment)
 
@@ -35,6 +106,33 @@ module Hitch
             "config.cache_store (Solid Cache, Redis, Memcached) or set #{setting} explicitly."
       end
 
+      # The boot-time counterpart to resolve, for the two checks that run while
+      # the application is still initializing.
+      #
+      # resolve asks ActionController::Base for the default store, and touching
+      # that class during initialization is a premature load: Rails 8.2 logs a
+      # warning with a full backtrace on every boot, and Rails has been
+      # promoting that class of warning to errors.
+      #
+      # Deferring with on_load(:action_controller_base) is worse than the
+      # warning and was shipped once. That hook fires from run_load_hooks at
+      # the end of the class body, while cache_store is assigned later still,
+      # from inside the on_load(:action_controller) block that
+      # action_controller.set_configs registers. The store came back nil and
+      # killed the boot — in the fall-back case the deferral existed for.
+      #
+      # config.action_controller.cache_store is the same value
+      # ActionController::Base.cache_store reads, and reading configuration
+      # loads no controller and defers nothing, so an unshared store still
+      # fails the boot. The trailing Rails.cache mirrors what set_configs
+      # itself defaults to, so this does not depend on having run after it.
+      def assert_shared_at_boot!(configured, setting:)
+        store = configured ||
+          Rails.application.config.action_controller.cache_store ||
+          Rails.cache
+        assert_shared!(store, setting: setting)
+      end
+
       # MemoryStore is per process, NullStore retains nothing, and FileStore
       # reads and writes without a lock.
       def unshared?(store)

data/lib/hitch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hitch
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/hitch.rb

@@ -6,10 +6,12 @@ require "hitch/rate_limit_store"
 require "hitch/engine"
 require "hitch/resource_uri"
 require "hitch/pkce"
+require "hitch/grant_types"
 require "hitch/mcp/protocol"
 require "hitch/mcp/configuration"
 require "hitch/configuration"
 require "hitch/dynamic_registration_rate_limit"
+require "hitch/device_authorization_rate_limit"
 
 # hitch-rails turns a Rails app into an authorization server implemented
 # against the MCP 2026-07-28 authorization profile — OAuth 2.1 + PKCE (S256),

data/lib/tasks/hitch.rake

@@ -126,7 +126,8 @@ namespace :hitch do
         credentials = Hitch::Client.register_confidential!(
           client_id: client_id,
           client_name: ENV["NAME"],
-          redirect_uris: [ redirect_uri ]
+          redirect_uris: [ redirect_uri ],
+          operator_registered: true
         )
         "client_id=#{credentials.client.client_id}\nclient_secret=#{credentials.client_secret}\n"
       end
@@ -140,6 +141,12 @@ namespace :hitch do
         client = Hitch::Client.find_by(client_id: client_id)
         abort "Confidential client not found" unless client&.confidential_client?
 
+        unless client.operator_registered?
+          client_name = ENV["NAME"].presence ||
+            abort("NAME is required when vouching for a client for device authorization")
+          client.update!(client_name: client_name, operator_registered: true)
+        end
+
         credentials = client.rotate_secret!
         "client_id=#{credentials.client.client_id}\nclient_secret=#{credentials.client_secret}\n"
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hitch-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tyler Klose
@@ -112,7 +112,9 @@ files:
 - MIT-LICENSE
 - README.md
 - SECURITY.md
+- app/controllers/concerns/hitch/client_resolution.rb
 - app/controllers/concerns/hitch/cors_support.rb
+- app/controllers/concerns/hitch/device_authorization_gate.rb
 - app/controllers/concerns/hitch/host_validation.rb
 - app/controllers/concerns/hitch/issuer_url.rb
 - app/controllers/concerns/hitch/mcp/endpoint.rb
@@ -121,8 +123,10 @@ files:
 - app/controllers/concerns/hitch/registration_admission.rb
 - app/controllers/concerns/hitch/request_admission.rb
 - app/controllers/concerns/hitch/uri_validation.rb
+- app/controllers/hitch/activations_controller.rb
 - app/controllers/hitch/application_controller.rb
 - app/controllers/hitch/authorizations_controller.rb
+- app/controllers/hitch/device_authorizations_controller.rb
 - app/controllers/hitch/metadata_controller.rb
 - app/controllers/hitch/preflights_controller.rb
 - app/controllers/hitch/public_endpoint_controller.rb
@@ -140,6 +144,8 @@ files:
 - app/models/hitch/client_id_metadata/fetcher.rb
 - app/models/hitch/client_id_metadata/throttle.rb
 - app/models/hitch/client_redirect_uri.rb
+- app/models/hitch/device_activation.rb
+- app/models/hitch/device_grant.rb
 - app/models/hitch/mcp/context.rb
 - app/models/hitch/mcp/forbidden.rb
 - app/models/hitch/mcp/internal.rb
@@ -167,13 +173,23 @@ files:
 - app/models/hitch/mcp/result.rb
 - app/models/hitch/mcp/tool.rb
 - app/models/hitch/oauth_request_parameters.rb
+- app/views/hitch/activations/confirm.html.erb
+- app/views/hitch/activations/done.html.erb
+- app/views/hitch/activations/new.html.erb
 - app/views/hitch/authorizations/new.html.erb
 - config/routes.rb
 - db/migrate/20260817000000_create_hitch_tables.rb
+- db/migrate/20260822000000_add_hitch_refresh_tokens.rb
+- db/migrate/20260824000000_create_hitch_device_grants.rb
+- db/migrate/20260824000001_enforce_hitch_device_grant_state.rb
+- db/migrate/20260824000002_add_operator_registration_provenance_to_hitch_clients.rb
+- docs/adr/0006-device-authorization-grant.md
 - docs/operator/doctor.md
 - docs/operator/rate_limiting.md
-- docs/public_api/0.2.0.md
+- docs/public_api/0.4.0.md
 - docs/removing.md
+- docs/upgrading/0.2-to-0.3.md
+- docs/upgrading/0.3-to-0.4.md
 - lib/generators/hitch/generator_guards.rb
 - lib/generators/hitch/install/install_generator.rb
 - lib/generators/hitch/install/templates/controller.rb.tt
@@ -185,9 +201,11 @@ files:
 - lib/hitch-rails.rb
 - lib/hitch.rb
 - lib/hitch/configuration.rb
+- lib/hitch/device_authorization_rate_limit.rb
 - lib/hitch/doctor.rb
 - lib/hitch/dynamic_registration_rate_limit.rb
 - lib/hitch/engine.rb
+- lib/hitch/grant_types.rb
 - lib/hitch/mcp/configuration.rb
 - lib/hitch/mcp/protocol.rb
 - lib/hitch/mcp/test_helper.rb
@@ -204,7 +222,7 @@ metadata:
   changelog_uri: https://github.com/tylerklose/hitch-rails/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/tylerklose/hitch-rails/issues
   allowed_push_host: https://rubygems.org
-  documentation_uri: https://github.com/tylerklose/hitch-rails/blob/v0.2.0/docs/public_api/0.2.0.md
+  documentation_uri: https://github.com/tylerklose/hitch-rails/blob/v0.4.0/docs/public_api/0.4.0.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: