rubybikes 0.3.0

data/lib/rubybikes/native/more_json.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Native adaptations of PyBikes clients, AGPL-3.0; see NOTICE for attribution.
+class RubyBikes
+  module Native
+    class JsonProviders
+      def update_baksi
+        JSON.parse(html_capture(request(p('feed_url')), /var all = (\[.*\]);/)).each do |s|
+          uid, name = s[0].split('-', 2)
+          station(name, s[5], s[6], number(s[2][/\d+/]), number(s[3][/\d+/]), { 'uid' => uid, 'online' => s[1].include?('Aktif') })
+        end
+      end
+
+      def update_chartered_bike
+        data = json('https://api.charteredbike.in/api/v1/stations/get-all-station',
+                    params: { 'lat' => 21.1940305, 'long' => 72.825347, 'version' => '1.9.2', 'buildNumber' => 283 }, headers: { 'User-Agent' => 'okhttp/3.12.1',
+                                                                                                                                 'Accept' => 'application/json, text/plain, */*' })
+        raise ProviderError, 'Provider returned unsuccessful status' unless data['status'] == 200
+
+        data.fetch('data').each do |s|
+          station(s['stationName'], s['latitude'], s['longitude'], number(s['bikesAvailable'] || 0), number(s['freeRacks']),
+                  { 'uid' => s['stationId'], 'ebikes' => number(s['ebikesAvailable'] || 0), 'number' => number(s['stationNumber']), 'online' => s['active'] })
+        end
+      end
+
+      def update_clujbike
+        JSON.parse(html_capture(request(p('feed_url')), /var stations = (\[.*?\]);/)).each do |s|
+          station(s['StationName'], s['Latitude'], s['Longitude'], number(s['OcuppiedSpots']), number(s['EmptyDoors']),
+                  { 'address' => s['Address'], 'status' => s['Status'] == 'Offline' ? 'offline' : 'online' })
+        end
+      end
+
+      def update_cykleo
+        json('https://portail.cykleo.fr/pu/stations/availability', params: { 'organization_id' => p('organization') },
+                                                                   headers: { 'Referer' => 'https://portail.cykleo.fr/',
+                                                                              'Content-Type' => 'application/json; charset=utf-8' }).each do |s|
+          info = s['station']['assetStation']
+          normal, electric = s.fetch('availableClassicBikeCount'), s.fetch('availableElectricBikeCount')
+          station(info['commercialName'], info['coordinate']['y'], info['coordinate']['x'], normal + electric, s['availableDockCount'],
+                  { 'uid' => s['id'], 'number' => info['commercialNumber'], 'ebikes' => electric, 'normal_bikes' => normal,
+                    'online' => s['station']['status'] == 'IN_SERVICE', 'status' => s['station']['status'] })
+        end
+      end
+
+      def update_easybike
+        if spec['class'] == 'EasyBikeNew'
+          data = json("https://#{p('city_uid')}.easybike.gr:8001/imet/v2/availability", headers: { 'Authorization' => 'Basic aW1ldDIwMTkwNTAxOkomZ2UjdXBQbUBNbT81aGI0eTZZ' })
+          data.fetch('stations').each { |s| station(s['label'], s['lat'], s['lng'], number(s['available']), number(s['spaces']), { 'uid' => s['station_id'] }) }
+        else
+          stations = json("http://reseller.easybike.gr/#{p('city_uid')}/api.php").fetch('stations')
+          raise ProviderError, 'Provider currently publishes no station feed' if stations.nil?
+
+          stations.each do |s|
+            station(s['description'], s['lat'], s['lng'], number(s['free_bikes']), number(s['free_spaces']), { 'slots' => number(s['total_spaces']) })
+          end
+        end
+      end
+
+      def update_open_source_bike_share
+        json(p('feed_url')).each do |s|
+          bikes = truthy?(s['bikecount']) ? s['bikecount'] : s.fetch('bikeCount')
+          station(s['standName'], s['lat'] || s['latitude'], s['lon'] || s['longitude'], number(bikes), integer(s['slotcount']),
+                  { 'uid' => number(s['standId']), 'photo' => s['standPhoto'], 'description' => s['standDescription'] })
+        end
+      end
+
+      def update_smoove
+        json(p('feed_url')).fetch('response').each do |s|
+          station(s['name'], s['coordinates'][0], s['coordinates'][1], number(s['avl_bikes']), number(s['free_slots']), { 'uid' => s['nid'], 'slots' => number(s['total_slots']) })
+        end
+      end
+
+      def update_veloway
+        json(p('feed_url')).fetch('stand').each do |s|
+          lat, lon = Float(s['lat']), Float(s['lng'])
+          next if lat.zero? && lon.zero?
+
+          # @type var extra: RubyBikes::object
+          extra = { 'uid' => number(s['id']), 'slots' => number(s['tc']), 'slots_available' => number(s['ac']), 'online' => number(s['disp']) == 1 }
+          extra['address'] = URI.decode_www_form_component(s['wcom'].to_s) if truthy?(s['wcom'])
+          station(URI.decode_www_form_component(s['name'].to_s), lat, lon, number(s['ab']), number(s['ap']), extra)
+        end
+      end
+
+      def update_wegoshare
+        json("#{p('endpoint')}/cxf/am/station/map/search", method: 'POST', data: JSON.generate('isPublic' => true, 'limit' => -1),
+                                                           headers: { 'Content-Type' => 'application/json; charset=utf-8' }).fetch('results').each do |s|
+          next if s['stationStatus'] == 'PLANNED'
+
+          station(s['name'], s['areaCentroid']['latitude'], s['areaCentroid']['longitude'], number(s['totalLockedCycleCount']), number(s['freeDocksCount']),
+                  { 'uid' => s['id'], 'description' => s['description'], 'address' => s['address'], 'online' => s['stationStatus'] == 'OPEN',
+                    'last_update' => s['lastUpdateCycleCountAt'],
+                    'photo' => s.key?('photoId') ? "#{p('endpoint')}/cxf/fm/files/#{s['photoId']}" : nil })
+        end
+      end
+
+      def update_yelovelo
+        json('https://opendata.agglo-larochelle.fr/d4c/api/records/2.0/downloadfile/format=json&resource_id=1f124bea-d55f-457f-9eab-b7877d803435').each do |item|
+          s = item.fetch('fields')
+          station(s['station_nom'], s['station_latitude'], s['station_longitude'], number(s['velos_disponibles']), number(s['accroches_libres']),
+                  { 'slots' => s['nombre_emplacements'] })
+        end
+      end
+
+      def update_youbike
+        taiwan = spec['class'] == 'YouBikeTw'
+        data = taiwan ? json('https://apis.youbike.com.tw/json/station-yb2.json') : json(p('feed_url')).fetch('retVal')
+        data.each do |s|
+          next if taiwan && s['area_code'] != p('uid')
+          next if s['lat'] == '' || s['lng'] == ''
+
+          language = taiwan ? 'tw' : 'cn'
+          # @type var extra: RubyBikes::object
+          extra = { 'uid' => s['station_no'], 'district' => s["district_#{language}"], 'address' => s["address_#{language}"], 'slots' => s['parking_spaces'],
+                    'last_updated' => s['updated_at'], 'online' => s['status'] == 1, 'youbike_version' => s['type'],
+                    'en' => { 'name' => s['name_en'], 'district' => s['district_en'], 'address' => s['address_en'] } }
+          if taiwan
+            extra['normal_bikes'] = s['available_spaces_detail']['yb1'] + s['available_spaces_detail']['yb2']
+            extra['ebikes'] = s['available_spaces_detail']['eyb']
+          end
+          station(s["name_#{language}"], s['lat'], s['lng'], number(s['available_spaces']), number(s['empty_spaces']), extra)
+        end
+      end
+    end
+  end
+end

data/lib/rubybikes/native/nextbike.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Adapted from PyBikes nextbike.py, Copyright eskerda and contributors, AGPL-3.0.
+class RubyBikes
+  module Native
+    class Nextbike < Provider
+      def initialize(spec, parameters, key: nil)
+        super
+        @parameters.fetch('domain')
+      end
+
+      def update
+        url = "https://#{p('hostname', 'maps.nextbike.net')}/maps/nextbike-live.xml"
+        document = Nokogiri::XML(request(url, params: { 'domains' => p('domain') })) { |config| config.strict.nonet }
+        places = document.xpath('/markers/country//city//place')
+        places = places.select { |place| place.ancestors('city').first['uid'] == p('city_uid').to_s } if p('city_uid')
+        raise ProviderError, 'Provider returned no places for this network' if places.empty?
+
+        places.each do |place|
+          latitude, longitude = Float(place['lat']), Float(place['lng'])
+          next if p('bbox') && !Geometry.contains?(p('bbox'), latitude, longitude)
+
+          if place['spot'] == '1'
+            extra = { 'uid' => place['uid'], 'virtual' => place['place_type'] == '17' }
+            extra['number'] = place['number'] if place['number']
+            bike_types = place['bike_types']
+            counts = if bike_types && !bike_types.strip.empty?
+                       JSON.parse(bike_types).values
+                     else
+                       [place['bikes']]
+                     end
+            extra['bikes_approximate'] = true if counts.any? { |count| count.to_s.end_with?('+') }
+            bikes = counts.sum { |count| number(count.to_s.delete_suffix('+')) }
+            free = nil
+            if place['bike_racks']
+              extra['slots'] = number(place['bike_racks'])
+              free = place['free_racks'] ? number(place['free_racks']) : extra['slots'] - bikes
+            end
+            extra['bike_uids'] = place['bike_numbers'].split(',').reject(&:empty?) if place['bike_numbers']
+            station(place['name'], latitude, longitude, bikes, free, extra)
+          end
+          if place['bike'] == '1'
+            bike = place.at_xpath('./bike')
+            vehicle(latitude, longitude, { 'uid' => bike['number'], 'online' => bike['active'] == '1' })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubybikes/native/provider.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'json'
+require 'csv'
+require 'nokogiri'
+
+class RubyBikes
+  module Native
+    class Provider
+      attr_reader :tag, :meta, :spec, :parameters
+
+      def initialize(spec, parameters, key: nil)
+        @spec = spec
+        @parameters = Marshal.load(Marshal.dump(parameters))
+        @tag = @parameters.fetch('tag')
+        defaults = Marshal.load(Marshal.dump(spec.fetch('meta')))
+        @meta = { 'name' => nil, 'city' => nil, 'country' => nil, 'latitude' => nil, 'longitude' => nil, 'company' => nil }.merge(defaults).merge(@parameters.fetch('meta'))
+        @meta['name'] ||= @meta['system'] || spec.fetch('class')
+        @key = key
+        raise APIKeyNotAvailableError, 'This provider requires an API key' if spec['authed'] && !truthy?(key)
+      end
+
+      def snapshot(transport)
+        @transport = transport
+        @stations, @vehicles = [], []
+        update
+        { 'tag' => tag, 'meta' => meta, 'stations' => @stations, 'vehicles' => @vehicles }
+      end
+
+      def station(name, latitude, longitude, bikes = nil, free = nil, extra = {})
+        latitude, longitude = Float(latitude), Float(longitude)
+        bounds = parameters['bbox']
+        return if bounds && !Geometry.contains?(bounds, latitude, longitude)
+
+        id = Digest::MD5.hexdigest("#{(latitude * 1e6).to_i},#{(longitude * 1e6).to_i}")
+        @stations << { 'id' => id, 'name' => name, 'latitude' => latitude, 'longitude' => longitude,
+                       'bikes' => bikes, 'free' => free, 'extra' => extra, 'timestamp' => Time.now.utc.iso8601(6) }
+      end
+
+      def vehicle(latitude, longitude, extra = {}, kind = 'bike')
+        latitude, longitude = Float(latitude), Float(longitude)
+        return if parameters['bbox'] && !Geometry.contains?(parameters['bbox'], latitude, longitude)
+
+        # @type var components: Array[String | Integer]
+        components = [tag]
+        if truthy?(extra['uid'])
+          components << extra['uid']
+        else
+          components.push((latitude * 1e6).to_i, (longitude * 1e6).to_i, kind)
+        end
+        @vehicles << { 'id' => Digest::MD5.hexdigest(components.join(',')), 'latitude' => latitude,
+                       'longitude' => longitude, 'kind' => kind, 'extra' => extra, 'timestamp' => Time.now.utc.iso8601(6) }
+      end
+
+      def request(url, **options) = @transport.request(url, **options)
+      def json(url, **options) = JSON.parse(request(url, **options))
+
+      def xml(url, **options)
+        Nokogiri::XML(request(url, **options)) { |config| config.nonet } # rubocop:disable Style/SymbolProc -- Preserve the typed parser configuration block.
+      end
+
+      def html(url, **options) = Nokogiri::HTML(request(url, **options))
+      def p(name, fallback = nil) = parameters.fetch(name, fallback)
+      def number(value) = value.is_a?(String) ? Integer(value, 10) : Integer(value)
+      def list(value) = Array(value)
+      def integer(value) = value.nil? ? nil : number(value)
+
+      def truthy?(value)
+        # @type var empty_list: Array[untyped]
+        empty_list = []
+        # @type var empty_object: RubyBikes::object
+        empty_object = {}
+        value && value != 0 && value != '' && value != empty_list && value != empty_object
+      end
+
+      def iso_date(value)
+        value.is_a?(Numeric) ? Time.at(value).utc.iso8601 : Time.iso8601(value).utc.iso8601
+      rescue ArgumentError, TypeError, RangeError
+        nil
+      end
+    end
+  end
+end

data/lib/rubybikes/native/remaining_clients.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Adapted from PyBikes cyclopolis.py and keolis.py.
+# Copyright (C) eskerda, Eduardo Mucelli Rezende Oliveira and contributors.
+# Distributed under the AGPL-3.0 license; see LICENSE.
+
+class RubyBikes
+  module Native
+    class JsonProviders
+      def update_cyclopolis
+        return update_cyclopolis_api if spec.fetch('class') == 'CyclopolisApi'
+
+        body = request(p('feed_url'))
+        coordinate_pattern = if p('mapstyle') == 'google'
+                               /latLng:\[(-?\d+\.\d+).*?(-?\d+\.\d+)\]/m
+                             else
+                               /"lat":\s?"(-?\d+\.\d+).*?"lon":\s?"(-?\d+\.\d+)/m
+                             end
+        coordinates = body.scan(coordinate_pattern)
+        descriptions = body.scan(%r{data"?:.*?<span.*?>(.*?)<\\?/span>}m).flatten
+        coordinates.zip(descriptions).each do |(latitude, longitude), description|
+          fields = description.gsub(%r{<\\?/?b>}, '').split(%r{<br.?/?>})
+          # @type var extra: RubyBikes::object
+          extra = {}
+          if fields.size == 4
+            name, raw_bikes, raw_free, status = fields
+          else
+            name, raw_bikes, raw_slots, raw_free, status = fields
+            extra['slots'] = number(raw_slots.split(':').last)
+          end
+          bikes = cyclopolis_count(raw_bikes.split(': ').last)
+          free = cyclopolis_count(raw_free.split(':').last)
+          extra['closed'] = true if status == 'offline'
+          station(name, latitude, longitude, bikes, free, extra)
+        end
+      end
+
+      def update_cyclopolis_api
+        json(p('feed_url')).each do |item|
+          bikes = item.fetch('vehicle_types_available').sum { |type| type.fetch('count') }
+          free = item.fetch('vehicle_docks_available').sum { |type| type.fetch('count') }
+          renting, returning = item.values_at('is_renting', 'is_returning')
+          extra = { 'uid' => item['id'], 'is_renting' => renting, 'is_returning' => returning,
+                    'online' => truthy?(renting) ? renting : returning }
+          coordinates = item.fetch('location').fetch('coordinates')
+          station(item['name'], coordinates[1], coordinates[0], bikes, free, extra)
+        end
+      end
+
+      def update_keolis
+        case spec.fetch('class')
+        when 'KeolisIlevia'
+          url = "https://data.lillemetropole.fr/data/ogcapi/collections/#{p('dataset')}/items"
+          json(url, params: { 'f' => 'json', 'limit' => -1 }).fetch('records').each do |fields|
+            extra = { 'status' => fields['etat'], 'uid' => fields['@id'].to_s,
+                      'city' => fields['commune'], 'address' => fields['adresse'],
+                      'last_update' => fields['date_modification'],
+                      'online' => fields['etat_connexion'] == 'CONNECTÉ',
+                      'payment-terminal' => fields['type'] == 'AVEC TPE' }
+            station(fields['nom'], fields['y'], fields['x'], number(fields['nb_velos_dispo']),
+                    number(fields['nb_places_dispo']), extra)
+          end
+        when 'KeolisSTAR'
+          @meta['source'] = @meta['source'].gsub('{dataset}', p('dataset').to_s) if @meta['source']
+          data = json('https://data.explore.star.fr/api/records/1.0/search/',
+                      params: { 'dataset' => p('dataset'), 'rows' => -1 })
+          data.fetch('records').each do |record|
+            fields = record.fetch('fields')
+            extra = { 'slots' => fields['nombreemplacementsactuels'], 'status' => fields['etat'],
+                      'uid' => fields['idstation'].to_s, 'last_update' => fields['lastupdate'],
+                      'online' => fields['etat'] == 'En fonctionnement', 'payment-terminal' => true }
+            coordinates = fields.fetch('coordonnees')
+            station(fields['nom'], coordinates[0], coordinates[1], number(fields['nombrevelosdisponibles']),
+                    number(fields['nombreemplacementsdisponibles']), extra)
+          end
+        when 'VCub'
+          json(p('feed_url')).fetch('lists').each do |fields|
+            ebikes = number(fields['nbElectricBikeAvailable'])
+            manual_bikes = number(fields['nbBikeAvailable'])
+            bikes, free = ebikes + manual_bikes, number(fields['nbPlaceAvailable'])
+            extra = { 'uid' => fields['id'].to_s, 'last_update' => fields['updatedAt'],
+                      'address' => fields['address'], 'city' => fields['city'],
+                      'online' => fields['connexionState'] == 'CONNECTEE', 'slots' => bikes + free,
+                      'ebikes' => ebikes, 'normal_bikes' => manual_bikes,
+                      'has_ebikes' => fields.key?('nbElectricBikeAvailable') }
+            station(fields['name'], fields['latitude'], fields['longitude'], bikes, free, extra)
+          end
+        else
+          raise NoSystemFoundError, 'Unknown Keolis client'
+        end
+      end
+
+      private
+
+      def cyclopolis_count(value)
+        number(value)
+      rescue ArgumentError
+        0
+      end
+    end
+  end
+end

data/lib/rubybikes/native/response_cache.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class RubyBikes
+  module Native
+    # A bounded response cache. Expiry uses the caller's monotonic clock;
+    # reads do not extend a response's lifetime.
+    class ResponseCache
+      Entry = Struct.new(:response, :stored_at, :bytes, keyword_init: true)
+
+      def initialize(ttl: 60, max_bytes: 32 * 1024 * 1024, max_entries: 128)
+        raise ArgumentError, 'cache TTL must be positive and finite' unless ttl.positive? && ttl.finite?
+        raise ArgumentError, 'cache byte limit must be positive' unless max_bytes.positive?
+        raise ArgumentError, 'cache entry limit must be positive' unless max_entries.positive?
+
+        @ttl, @max_bytes, @max_entries = ttl, max_bytes, max_entries
+        @entries = {}
+        @bytes = 0
+        @mutex = Mutex.new
+      end
+
+      def get(key, now)
+        atomic do
+          expire(now)
+          @entries[key]&.response
+        end
+      end
+
+      def put(key, response, now)
+        size = response.body.bytesize
+        if size > @max_bytes
+          atomic do
+            expire(now)
+            previous = @entries.delete(key)
+            @bytes -= previous.bytes if previous
+          end
+          return nil
+        end
+        # The transport exposes mutable configuration and last_response, so
+        # neither the caller's cache key nor response should back stored data.
+        saved_key = Marshal.load(Marshal.dump(key))
+        saved_response = response.dup
+        saved_response.body = response.body.dup.freeze
+        saved_response.headers = response.headers.transform_values { |value| value.dup.freeze }.freeze
+        saved_response.freeze
+        atomic do
+          expire(now)
+          previous = @entries.delete(key)
+          @bytes -= previous.bytes if previous
+          while @entries.length >= @max_entries || @bytes + size > @max_bytes
+            oldest = @entries.shift
+            @bytes -= oldest[1].bytes if oldest
+          end
+          @entries[saved_key] = Entry.new(response: saved_response, stored_at: now, bytes: size)
+          @bytes += size
+        end
+        nil
+      end
+
+      private
+
+      def atomic(&block)
+        # Defer asynchronous timer delivery only while updating accounting.
+        # Synchronous errors still propagate; no network I/O runs here.
+        Thread.handle_interrupt(Exception => :never) do
+          @mutex.synchronize(&block)
+        end
+      end
+
+      def expire(now)
+        @entries.delete_if do |_, entry|
+          expired = now - entry.stored_at >= @ttl
+          @bytes -= entry.bytes if expired
+          expired
+        end
+      end
+    end
+  end
+end

data/lib/rubybikes/native/transport.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'time'
+require 'timeout'
+require 'http/cookie_jar'
+
+class RubyBikes
+  module Native
+    class Transport
+      Response = Struct.new(:status, :headers, :body, keyword_init: true)
+      attr_reader :headers, :last_response
+
+      def initialize(timeout: 60, headers: {}, proxy: nil, cooldowns: {}, cache: nil, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @clock = clock
+        seconds = Float(timeout, exception: true)
+        raise ArgumentError, 'timeout must be positive' unless seconds&.positive? && seconds.finite?
+
+        @deadline = @clock.call + seconds
+        @headers = { 'User-Agent' => "RubyBikes/#{RubyBikes::VERSION}" }.merge(headers)
+        @proxy = proxy && URI(proxy)
+        @cooldowns = cooldowns
+        @cookies = HTTP::CookieJar.new
+        @cache = cache || ResponseCache.new
+        @deadline_active = false
+      end
+
+      def remaining
+        seconds = @deadline - @clock.call
+        raise TimeoutError, 'Provider update exceeded its deadline' unless seconds.positive?
+
+        seconds
+      end
+
+      def within_deadline
+        return yield if @deadline_active
+
+        @deadline_active = true
+        begin
+          Timeout.timeout(remaining) { yield } # rubocop:disable Style/ExplicitBlockArgument -- The timer passes an argument; provider blocks take none.
+        rescue Timeout::Error
+          raise TimeoutError, 'Provider update exceeded its deadline'
+        ensure
+          @deadline_active = false
+        end
+      end
+
+      def request(url, method: 'GET', params: nil, data: nil, headers: {}, raw: false, skip_cache: false, default_encoding: 'UTF-8')
+        within_deadline do
+          perform_request(url, method: method, params: params, data: data, headers: headers, raw: raw, skip_cache: skip_cache, default_encoding: default_encoding)
+        end
+      end
+
+      private
+
+      def perform_request(url, method:, params:, data:, headers:, raw:, skip_cache:, default_encoding:)
+        remaining
+        uri = transport_uri(url)
+        uri.query = [uri.query, params && URI.encode_www_form(params)].compact.reject(&:empty?).join('&')
+        uri.query = nil if uri.query == ''
+        host = uri.host
+        raise ArgumentError, 'Provider URL must include a host' unless host
+
+        until_time = @cooldowns.fetch(host, 0.0)
+        raise RateLimitedError.new('Provider rate limit reached', details: { 'host' => uri.host, 'retry_after' => until_time - Time.now.to_f }) if until_time > Time.now.to_f
+
+        combined = @headers.merge(headers)
+        cookies = @cookies.cookies(uri)
+        combined['Cookie'] = cookies.map { |cookie| "#{cookie.name}=#{cookie.value}" }.join('; ') unless cookies.empty?
+        cache_key = [method, uri.to_s, data, combined]
+        cached = @cache.get(cache_key, @clock.call) if method == 'GET' && !skip_cache
+        if cached
+          @last_response = cached
+          return decode(@last_response, raw, default_encoding)
+        end
+        response = fetch(uri, method, data, combined, 5)
+        @last_response = response
+        if response.status == 429
+          value = response.headers.fetch('retry-after', '300')
+          delay = begin
+            Float(value)
+          rescue ArgumentError
+            begin
+              Time.httpdate(value).to_f - Time.now.to_f
+            rescue ArgumentError
+              300
+            end
+          end
+          delay = [[delay, 1].max, 86_400].min # rubocop:disable Style/ComparableClamp -- Preserve rejection of non-comparable Retry-After values.
+          @cooldowns[host] = Time.now.to_f + delay
+          raise RateLimitedError.new('Provider rate limit reached', details: { 'host' => uri.host, 'retry_after' => delay })
+        end
+        @cache.put(cache_key, response, @clock.call) if method == 'GET' && response.status.between?(200, 299) && !skip_cache
+        decode(response, raw, default_encoding)
+      end
+
+      def decode(response, raw, default_encoding)
+        body = response.body
+        if raw
+          body.b
+        else
+          body.dup.force_encoding(response.headers.fetch('content-type', '')[/charset\s*=\s*"?([^;"\s]+)/i, 1] || default_encoding).encode('UTF-8', invalid: :replace,
+                                                                                                                                                    undef: :replace)
+        end
+      end
+
+      def transport_uri(url)
+        uri = URI(url)
+        raise ArgumentError, 'Provider URL must use HTTP or HTTPS' unless uri.is_a?(URI::HTTP)
+
+        uri
+      end
+
+      def fetch(uri, method, data, headers, redirects)
+        proxy = @proxy
+        http_class = if proxy
+                       proxy_host = proxy.host
+                       raise ArgumentError, 'Proxy URL must include a host' unless proxy_host
+
+                       Net::HTTP::Proxy(proxy_host, proxy.port, proxy.user, proxy.password)
+                     else
+                       Net::HTTP
+                     end
+        host = uri.host
+        raise ArgumentError, 'Provider URL must include a host' unless host
+
+        http = http_class.new(host, uri.port)
+        http.max_retries = 0
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = [5, remaining].min
+        http.read_timeout = [20, remaining].min
+        http.write_timeout = [20, remaining].min
+        # Net::HTTP accepts its generic request base class at this boundary.
+        # @type var request: untyped
+        request = Net::HTTPGenericRequest.new(method, !data.nil?, method != 'HEAD', uri.request_uri, headers)
+        if data.is_a?(Hash)
+          request.set_form_data(data)
+        elsif data
+          request.body = data
+        end
+        response = http.start { |connection| connection.request(request) }
+        response.get_fields('set-cookie')&.each { |cookie| @cookies.parse(cookie, uri) }
+        if response.is_a?(Net::HTTPRedirection)
+          raise ProviderError, 'Provider exceeded the redirect limit' if redirects.zero?
+
+          target = transport_uri(URI.join(uri.to_s, response.fetch('location')).to_s)
+          forwarded = headers.dup
+          forwarded.reject! { |key, _| %w[authorization cookie].include?(key.downcase) } if [target.scheme, target.host, target.port] != [uri.scheme, uri.host, uri.port]
+          cookies = @cookies.cookies(target)
+          forwarded['Cookie'] = cookies.map { |cookie| "#{cookie.name}=#{cookie.value}" }.join('; ') unless cookies.empty?
+          redirect_method = if (%w[302 303].include?(response.code) && method != 'HEAD') || (response.code == '301' && method == 'POST')
+                              'GET'
+                            else
+                              method
+                            end
+          return fetch(target, redirect_method, redirect_method == method ? data : nil, forwarded, redirects - 1)
+        end
+        Response.new(status: response.code.to_i, headers: response.each_header.to_h, body: response.body || '')
+      end
+    end
+  end
+end