statifier 0.0.1 → 0.1.0

data/lib/statifier/basichttp/net_http_transport.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Statifier
+  module BasicHTTP
+    # The default transport, on the standard library's Net::HTTP (the
+    # `net-http` default gem), so it adds no runtime dependency.
+    #
+    # Each {#call} makes one request once, on a connection of its own that
+    # it opens and closes, and answers the {Response}, whatever its status;
+    # retrying is not a transport's job. It raises a {TransportError} when no
+    # response came back: a URL that is not an absolute `http` or `https` URL
+    # with a host (no connection is then opened); any error raised while it
+    # connects, sends or reads, a host's `connect` included, which is then
+    # the error's `cause`; or a response it cannot build a {Response} from:
+    # a status line outside 100 to 599, a header name that is not an HTTP
+    # token, or a header value holding a carriage return, a line feed or a
+    # NUL.
+    #
+    # Net::HTTP adds the headers it always adds (`host`, `content-length`
+    # (`0` for an empty body, a GET included), and the `accept-encoding`,
+    # `accept` and `user-agent` defaults) unless the
+    # request names them, and a response body it decodes from `gzip` or
+    # `deflate` is answered decoded. Two headers of one name in a request are
+    # sent as one header, their values joined by a comma.
+    #
+    # @example
+    #   transport = Statifier::BasicHTTP::NetHTTPTransport.new(timeout: 2)
+    #   request = Statifier::BasicHTTP::Request.new(http_method: "POST", url: "http://localhost:8080/s1", body: "e.go")
+    #   begin
+    #     transport.call(request).status # => 200
+    #   rescue Statifier::BasicHTTP::TransportError => e
+    #     e.message # why no response came back
+    #   end
+    class NetHTTPTransport
+      # How long, in seconds, each of opening the connection, writing the
+      # request and reading the response may take when the host names no
+      # bound: the reference's five seconds.
+      DEFAULT_TIMEOUT = 5
+
+      # The connection the default transport opens for `uri`: a Net::HTTP
+      # object, not yet started, for its host and port, using TLS for an
+      # `https` URL (with Net::HTTP's default, the peer verified against the
+      # default certificate store), each of its open, TLS handshake, write
+      # and read bounds `timeout` seconds. A host's own `connect:` callable
+      # may call this and change the answer before it returns it (a proxy, a
+      # certificate file).
+      #
+      # @param uri [URI::HTTP] the URL requested
+      # @param timeout [Numeric] the bound on each step, in seconds
+      # @return [Net::HTTP] the connection, not started
+      def self.connection(uri, timeout: DEFAULT_TIMEOUT)
+        Net::HTTP.new(uri.host, uri.port).tap do |http|
+          http.use_ssl = uri.scheme == "https"
+          http.open_timeout = timeout
+          http.ssl_timeout = timeout
+          http.write_timeout = timeout
+          http.read_timeout = timeout
+        end
+      end
+
+      # @param timeout [Numeric] the bound, in seconds, on each of opening
+      #   the connection, writing the request and reading the response;
+      #   {DEFAULT_TIMEOUT} when absent
+      # @param connect [#call, nil] answers the connection for a URL, called
+      #   with the request's `URI::HTTP`; the connection answers `start`
+      #   with a block, yielding something that answers `request` with a
+      #   `Net::HTTPGenericRequest` and returns its `Net::HTTPResponse`, as
+      #   a Net::HTTP object does. {connection} with `timeout` when nil; a
+      #   host's own sets its own bounds, so the two are not given together
+      # @raise [ArgumentError] for a timeout that is not a positive finite
+      #   number, a `connect` that does not answer `call`, or both given
+      def initialize(timeout: nil, connect: nil)
+        raise ArgumentError, "give timeout or connect, not both" if timeout && connect
+        raise ArgumentError, "expected connect to answer call" unless connect.nil? || connect.respond_to?(:call)
+
+        @timeout = timeout.nil? ? DEFAULT_TIMEOUT : checked_timeout(timeout)
+        @connect = connect
+        freeze
+      end
+
+      # The connection a {#call} for `uri` opens, not yet started: what the
+      # host's `connect` answers for it, or {connection} with this
+      # transport's timeout when the host gave none.
+      #
+      # @param uri [URI::HTTP] the URL requested
+      # @return [Net::HTTP, Object] the connection
+      def connect(uri) = @connect ? @connect.call(uri) : self.class.connection(uri, timeout: @timeout)
+
+      # Makes `request` once and answers what came back.
+      #
+      # @param request [Request] the request
+      # @return [Response] the response, whatever its status
+      # @raise [TransportError] when no response came back
+      # @raise [TypeError] for a request that is not a {Request}
+      def call(request)
+        raise TypeError, "expected a #{Request}, got #{request.class}" unless request.is_a?(Request)
+
+        make(request)
+      end
+
+      private
+
+      # The request made, every error but a {TransportError} raised as one
+      # whose `cause` it is.
+      def make(request)
+        uri = target(request.url)
+        response(exchange(uri, net_request(request, uri)))
+      rescue TransportError
+        raise
+      rescue StandardError => e
+        raise TransportError, "#{e.class}: #{e.message}"
+      end
+
+      def checked_timeout(timeout)
+        return timeout if timeout.is_a?(Numeric) && timeout.real? && timeout.positive? && timeout.to_f.finite?
+
+        raise ArgumentError, "expected timeout to be a positive finite number of seconds, got #{timeout.inspect}"
+      end
+
+      # The request's URL as an absolute `http` or `https` URI with a host.
+      def target(url)
+        uri = URI.parse(url)
+        return uri if uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+
+        raise TransportError, "not an absolute http or https URL: #{url}"
+      rescue URI::InvalidURIError => e
+        raise TransportError, "not a URL: #{e.message}"
+      end
+
+      # `request` as Net::HTTP's request for `uri`: the first header of a
+      # name replaces Net::HTTP's default of that name, and a later one is
+      # added to it.
+      def net_request(request, uri)
+        net = Net::HTTPGenericRequest.new(request.http_method, true, request.http_method != "HEAD", uri.request_uri)
+        named = {}
+        request.headers.each do |name, value|
+          named.key?(name.downcase) ? net.add_field(name, value) : net[name] = value
+          named[name.downcase] = true
+        end
+        net.body = request.body
+        net
+      end
+
+      def exchange(uri, net_request)
+        connect(uri).start { |http| http.request(net_request) }
+      end
+
+      def response(net_response)
+        headers = net_response.to_hash.flat_map { |name, values| values.map { [name, _1] } }
+        Response.new(status: Integer(net_response.code, 10), headers:, body: net_response.body.to_s)
+      end
+    end
+  end
+end

data/lib/statifier/basichttp/outbound.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Statifier
+  module BasicHTTP
+    # The request each send the {Processor} is handed becomes, and the
+    # send's deduplication key, built as the reference's processor builds
+    # them (the {Processor} says how).
+    #
+    # @api private
+    module Outbound
+      # The form parameter that carries the event name.
+      EVENT_NAME_PARAM = "_scxmleventname"
+
+      # The content type of a form body.
+      FORM = "application/x-www-form-urlencoded"
+
+      # The header that carries the send's deduplication key.
+      SEND_KEY_HEADER = "scxml-send-key"
+
+      module_function
+
+      # The request one send becomes ({Processor} says how).
+      #
+      # @param session_id [String] the sending session's id
+      # @param send [Statifier::Effect::Send, Statifier::Effect::SendDelayed]
+      #   a send whose target is a String
+      # @return [Request]
+      def request(session_id, send)
+        url, content_type, body = message(send)
+        Request.new(http_method: "POST", url:, headers: [["content-type", content_type],
+                                                         [SEND_KEY_HEADER, send_key(session_id, send)]], body:)
+      end
+
+      # The URL, the content type and the body of the send's request.
+      def message(send)
+        named = send.event ? [[EVENT_NAME_PARAM, Encoding.value(send.event)]] : []
+        data = send.data
+        if data.is_a?(Hash)
+          [send.target, FORM, Encoding.form(named + fields(data))]
+        elsif data.equal?(Predicator::UNDEFINED)
+          [send.target, FORM, Encoding.form(named)]
+        else
+          [with_query(send.target, named), "text/plain", Encoding.value(data)]
+        end
+      end
+
+      # A Hash's names and values as form fields, in the byte order of the
+      # names.
+      def fields(data)
+        data.map { |name, value| [Encoding.value(name), Encoding.value(value)] }.sort_by { _1.first.b }
+      end
+
+      # A send's deduplication key, as the `scxml-send-key` header carries
+      # it and the reference spells it: eight fields joined by `/`, the
+      # session's id and the send id escaped ({Encoding.field}), the
+      # macrostep, microstep, round and content index in decimal, the owner
+      # (`onentry.S.B`, `onexit.S.B`, `finalize.S.B` with the state's index
+      # and the block's, or `transition.T`) and the ordinal; a field the send
+      # does not carry is empty.
+      #
+      # @param session_id [String] the sending session's id
+      # @param send [Statifier::Effect::Send, Statifier::Effect::SendDelayed]
+      # @return [String]
+      def send_key(session_id, send)
+        [Encoding.field(session_id), Encoding.field(send.send_id), send.macrostep, send.microstep, send.round,
+         send.c_index, owner(send.owner), send.ordinal].join("/")
+      end
+
+      # A content owner as the key spells it.
+      def owner(owner)
+        case owner&.fetch(:kind)
+        when :onentry, :onexit then "#{owner[:kind]}.#{owner[:state_index]}.#{owner[:ordinal]}"
+        when :finalize then "finalize.#{owner[:state_index]}.#{owner[:invoke_index]}"
+        when :transition then "transition.#{owner[:t_index]}"
+        end
+      end
+
+      # `url` with the pairs appended as a query string, after `&` when it
+      # already carries one.
+      def with_query(url, pairs)
+        return url if pairs.empty?
+
+        "#{url}#{url.include?("?") ? "&" : "?"}#{Encoding.form(pairs)}"
+      end
+    end
+  end
+end

data/lib/statifier/basichttp/processor.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Statifier
+  module BasicHTTP
+    # A send the processor could not deliver, as it hands it to the host's
+    # `report:` callable: the host passes `effect` and `reason` to
+    # {Statifier.report_send_failed} with the state it holds for
+    # `session_id`.
+    #
+    # @!attribute [r] session_id
+    #   @return [String] the sending session's id
+    # @!attribute [r] effect
+    #   @return [Statifier::Effect::Send, Statifier::Effect::SendDelayed] the
+    #     send the processor was handed
+    # @!attribute [r] reason
+    #   @return [Symbol] why: `:http_status` (a response outside 2xx),
+    #     `:transport_error` (the transport raised), `:invalid_target` (a
+    #     target that is not a String) or `:no_timer` (a delayed send, which
+    #     this processor holds no timer for)
+    # @!attribute [r] detail
+    #   @return [Object, nil] the {Response} for `:http_status`; for
+    #     `:transport_error`, the error the transport raised, or a TypeError
+    #     when it answered something that is not a {Response}; the target
+    #     for `:invalid_target`; nil for `:no_timer`
+    Failure = ::Data.define(:session_id, :effect, :reason, :detail)
+
+    # The Basic HTTP Event I/O Processor (SCXML appendix C.2), outbound, as
+    # the reference's `Statifier.Send.BasicHTTP` is: a processor a host
+    # registers like any other, under {EVENT_PROCESSOR} and its short form
+    # {SHORT_TYPE} ({#send_types} names it under both).
+    #
+    # Each send it is handed becomes one POST, made once through the
+    # transport while `deliver` runs. The request is built from the send's
+    # data, as the reference builds it:
+    #
+    # - a Hash is a form body (`application/x-www-form-urlencoded`): the
+    #   event name as the `_scxmleventname` parameter, then each name and
+    #   value, in the byte order of the names (the reference lists a map of
+    #   more than 32 names in an order of its own, so such a body differs);
+    # - no data (`Predicator::UNDEFINED`) is a form body of the event name
+    #   alone;
+    # - any other value is the body, as `text/plain`, with the event name as
+    #   `_scxmleventname` in the target's query string.
+    #
+    # A value is written as {Encoding.value} writes it, and a send with no
+    # event name carries no `_scxmleventname`. Every request carries the
+    # send's deduplication key in the `scxml-send-key` header, the same
+    # value each time the same send is handed, so a receiver that
+    # deduplicates on it takes each send once.
+    #
+    # A send with no target fails within the call that handed it, as
+    # appendix C.2.2 requires: `deliver` answers a
+    # {Statifier::Driver::DeliveryFailure} and makes no request. Any other
+    # miss is handed to the host's `report:` callable as a {Failure} before
+    # `deliver` returns, as the reference's processor reports a miss to the
+    # sending session, which takes it after the step it is in: a response
+    # outside 2xx, a transport that raised, a target that is not a String
+    # and a delayed send, which this processor holds no timer for. The host
+    # passes each to {Statifier.report_send_failed} once the call that
+    # handed the send has returned, with the state that call answered.
+    #
+    # The processor keeps nothing between sends and is frozen; one
+    # processor serves every session it is registered for.
+    #
+    # @example
+    #   misses = []
+    #   http = Statifier::BasicHTTP::Processor.new(base_url: "http://localhost:8080/scxml", report: misses.method(:<<))
+    #   moved = Statifier.start(machine, session_id: "s1", processors: http.send_types).value
+    #   misses.each do |miss|
+    #     moved = Statifier.report_send_failed(machine, moved.state, miss.effect, reason: miss.reason,
+    #                                          processors: http.send_types).value
+    #   end
+    class Processor
+      # @return [String] the address the host's own front answers at
+      attr_reader :base_url
+
+      # @param base_url [String] the address the host's own front answers
+      #   at; a session's `_ioprocessors` location is this address, `/` and
+      #   the session's id. Copied, never frozen in place
+      # @param report [#call] takes each {Failure}, before `deliver`
+      #   returns; its answer is not read, and an error it raises is not
+      #   caught
+      # @param transport [#call, nil] makes each request ({BasicHTTP} says
+      #   what a transport is); a {NetHTTPTransport} with its defaults when
+      #   nil
+      # @raise [TypeError] for a base URL that is not a String
+      # @raise [ArgumentError] for an empty base URL, or a `report` or a
+      #   `transport` that does not answer `call`
+      def initialize(base_url:, report:, transport: nil)
+        raise ArgumentError, "expected report to answer call" unless report.respond_to?(:call)
+        raise ArgumentError, "expected transport to answer call" unless transport.nil? || transport.respond_to?(:call)
+
+        @base_url = address(base_url)
+        @report = report
+        @transport = transport || NetHTTPTransport.new
+        freeze
+      end
+
+      # The send types to register this processor under, as a host passes
+      # them in `processors:`: {EVENT_PROCESSOR} and {SHORT_TYPE}, so a chart
+      # may name either and `_ioprocessors` carries an entry under each.
+      #
+      # @return [Hash{String => Processor}] a frozen Hash
+      def send_types = { EVENT_PROCESSOR => self, SHORT_TYPE => self }.freeze
+
+      # The `_ioprocessors` entry for a session (appendix C.2.3): its
+      # `"location"`, the base URL, `/` and the session's id, the same under
+      # either type.
+      #
+      # @param _type [String] the type it is registered under
+      # @param context [Statifier::Driver::Context] the session
+      # @return [Hash{String => String}] a frozen Hash
+      def ioprocessors_entry(_type, context) = { "location" => "#{base_url}/#{context.session_id}".freeze }.freeze
+
+      # Takes one send (see the class's description): makes its request, or
+      # answers a {Statifier::Driver::DeliveryFailure} for a send with no
+      # target.
+      #
+      # @param send [Statifier::Effect::Send, Statifier::Effect::SendDelayed]
+      # @param _event [Statifier::Event] the event a delivery would carry,
+      #   not read
+      # @param context [Statifier::Driver::Context] the sending session
+      # @return [Statifier::Driver::DeliveryFailure, nil]
+      def deliver(send, _event, context)
+        return Driver::DeliveryFailure.new(reason: :no_target) if send.target.nil?
+
+        session_id = context.session_id
+        return miss(session_id, send, :no_timer, nil) if send.is_a?(Effect::SendDelayed)
+        return miss(session_id, send, :invalid_target, send.target) unless send.target.is_a?(String)
+
+        post(session_id, send)
+      end
+
+      private
+
+      # `base_url`, checked, as a frozen copy.
+      def address(base_url)
+        raise TypeError, "expected base_url to be a String, got #{base_url.class}" unless base_url.is_a?(String)
+        raise ArgumentError, "expected base_url to be an address, got an empty String" if base_url.empty?
+
+        base_url.frozen? ? base_url : base_url.dup.freeze
+      end
+
+      # The send's request made once, and a miss handed to the host.
+      def post(session_id, send)
+        answered = exchange(Outbound.request(session_id, send))
+        return miss(session_id, send, :transport_error, answered) if answered.is_a?(Exception)
+        return miss(session_id, send, :http_status, answered) unless (200..299).cover?(answered.status)
+
+        nil
+      end
+
+      # What the transport answered for `request`: its {Response}, or the
+      # error it raised, a transport that answers anything but a {Response}
+      # answered as a TypeError.
+      def exchange(request)
+        answered = @transport.call(request)
+        answered.is_a?(Response) ? answered : TypeError.new("expected a #{Response}, got #{answered.class}")
+      rescue StandardError => e
+        e
+      end
+
+      # A miss handed to the host's `report:`; `deliver` answers nil.
+      def miss(session_id, send, reason, detail)
+        @report.call(Failure.new(session_id:, effect: send, reason:, detail:))
+        nil
+      end
+    end
+  end
+end

data/lib/statifier/basichttp/request.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Statifier
+  module BasicHTTP
+    # One request a transport makes, a frozen value, deeply: a string it
+    # is built from that is not frozen is copied, never frozen in place, and
+    # one already frozen is kept. A transport sends it
+    # as it is handed and changes nothing in it.
+    #
+    # @example
+    #   request = Statifier::BasicHTTP::Request.new(
+    #     http_method: "POST",
+    #     url: "http://localhost:8080/s1",
+    #     headers: [["content-type", "text/plain"]],
+    #     body: "e.go"
+    #   )
+    #
+    # @!attribute [r] http_method
+    #   @return [String] the HTTP method, an HTTP token such as `"POST"`
+    # @!attribute [r] url
+    #   @return [String] the absolute URL requested
+    # @!attribute [r] headers
+    #   @return [Array<Array(String, String)>] name and value pairs, in
+    #     order; a name may appear more than once. Each name is an HTTP
+    #     token, and no value holds a carriage return, a line feed or a NUL
+    # @!attribute [r] body
+    #   @return [String] the body, already encoded; empty for none
+    Request = ::Data.define(:http_method, :url, :headers, :body) do
+      # @param http_method [String] the HTTP method
+      # @param url [String] the absolute URL
+      # @param headers [Array<Array(String, String)>] name and value pairs;
+      #   none when absent
+      # @param body [String] the body; empty when absent
+      # @raise [TypeError] for a member of the wrong kind
+      # @raise [ArgumentError] for a method or a header name that is not an
+      #   HTTP token, or a header value holding a carriage return, a line
+      #   feed or a NUL
+      def initialize(http_method:, url:, headers: [], body: "")
+        super(
+          http_method: Values.token(http_method, "http_method"),
+          url: Values.string(url, "url"),
+          headers: Values.headers(headers),
+          body: Values.string(body, "body")
+        )
+      end
+    end
+
+    # The checks and copies {Request} and {Response} make of what they are
+    # built from.
+    #
+    # @api private
+    module Values
+      module_function
+
+      # An HTTP token (RFC 9110, section 5.6.2).
+      TOKEN = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
+
+      # `value`, a String, as a frozen copy.
+      def string(value, field)
+        raise TypeError, "expected #{field} to be a String, got #{value.class}" unless value.is_a?(String)
+
+        value.frozen? ? value : value.dup.freeze
+      end
+
+      # `value`, an HTTP token, as a frozen copy.
+      def token(value, field)
+        copy = string(value, field)
+        raise ArgumentError, "expected #{field} to be an HTTP token, got #{copy.inspect}" unless TOKEN.match?(copy)
+
+        copy
+      end
+
+      # `value`, a list of name and value pairs, as a frozen copy.
+      def headers(value)
+        raise TypeError, "expected headers to be an Array of pairs, got #{value.class}" unless value.is_a?(Array)
+
+        value.map { header(_1) }.freeze
+      end
+
+      # One name and value pair, as a frozen copy.
+      def header(pair)
+        unless pair.is_a?(Array) && pair.size == 2
+          raise TypeError, "expected each header to be a [name, value] pair, got #{pair.inspect}"
+        end
+
+        name = token(pair[0], "a header name")
+        value = string(pair[1], "a header value")
+        raise ArgumentError, "the value of header #{name} holds CR, LF or NUL" if value.match?(/[\r\n\0]/)
+
+        [name, value].freeze
+      end
+    end
+  end
+end

data/lib/statifier/basichttp/response.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Statifier
+  module BasicHTTP
+    # The response a transport answers, whatever its status: a status
+    # outside 2xx is a response, not a {TransportError}. A frozen value,
+    # deeply: a string it is built from that is not frozen is copied, never
+    # frozen in place, and one already frozen is kept.
+    #
+    # @!attribute [r] status
+    #   @return [Integer] the HTTP status code, from 100 to 599
+    # @!attribute [r] headers
+    #   @return [Array<Array(String, String)>] name and value pairs, in the
+    #     order the transport read them; a name may appear more than once.
+    #     {NetHTTPTransport} answers every name in lower case
+    # @!attribute [r] body
+    #   @return [String] the body as the transport read it; empty for none
+    Response = ::Data.define(:status, :headers, :body) do
+      # @param status [Integer] the HTTP status code
+      # @param headers [Array<Array(String, String)>] name and value pairs;
+      #   none when absent
+      # @param body [String] the body; empty when absent
+      # @raise [TypeError] for a member of the wrong kind
+      # @raise [ArgumentError] for a status outside 100 to 599, or a header
+      #   as {Request} refuses one
+      def initialize(status:, headers: [], body: "")
+        raise TypeError, "expected status to be an Integer, got #{status.class}" unless status.is_a?(Integer)
+        raise ArgumentError, "expected status to be from 100 to 599, got #{status}" unless (100..599).cover?(status)
+
+        super(status:, headers: Values.headers(headers), body: Values.string(body, "body"))
+      end
+    end
+  end
+end

data/lib/statifier/basichttp.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../statifier"
+
+module Statifier
+  # The Basic HTTP Event I/O Processor (SCXML appendix C.2), loaded only by
+  # `require "statifier/basichttp"`: `require "statifier"` alone loads none
+  # of it, and so loads no HTTP library.
+  #
+  # It holds three things. The {Processor}, a send processor a host
+  # registers under {EVENT_PROCESSOR} and {SHORT_TYPE}, turns each send it
+  # is handed into one POST. {BasicHTTP.decode} turns an HTTP request a
+  # host's own server took into the event it carries. And the HTTP
+  # transport is the seam between the processor and whatever makes a
+  # request. A transport is anything that responds to `call` (a lambda, a
+  # method object, an object): it takes one {Request} (the method, the URL,
+  # the headers and the body) and makes it, and it answers the {Response}
+  # that came back (the status, the headers and the body), whatever its
+  # status, or raises a {TransportError} when no response came back.
+  # {NetHTTPTransport} is the default transport, on the standard library's
+  # Net::HTTP, and a host may pass any other callable of the same contract
+  # instead.
+  module BasicHTTP
+    # The processor's type, appendix C.2's URI.
+    EVENT_PROCESSOR = "http://www.w3.org/TR/scxml/#BasicHTTPEventProcessor"
+
+    # The processor's short type, which a chart may name in its place.
+    SHORT_TYPE = "basichttp"
+
+    # A transport answered no response: the URL could not be requested, the
+    # connection failed or was refused, a time bound passed, or the exchange
+    # broke off. This is the one error a transport raises for a request it
+    # could not make; the error that caused it, when there was one, is its
+    # `cause`.
+    class TransportError < StandardError; end
+
+    require_relative "basichttp/request"
+    require_relative "basichttp/response"
+    require_relative "basichttp/net_http_transport"
+    require_relative "basichttp/encoding"
+    require_relative "basichttp/outbound"
+    require_relative "basichttp/processor"
+    require_relative "basichttp/decode"
+
+    private_constant :Decode, :Encoding, :Outbound, :Values
+  end
+end