http-2 0.11.0 → 1.0.0

data/sig/connection.rbs

@@ -0,0 +1,93 @@
+module HTTP2
+  class Connection
+    include FlowBuffer
+    include Emitter
+
+    REQUEST_MANDATORY_HEADERS: Array[String]
+    RESPONSE_MANDATORY_HEADERS: Array[String]
+
+    attr_reader state: Symbol
+
+    attr_reader local_window: Integer
+    attr_reader remote_window: Integer
+
+    alias window local_window
+
+    attr_reader remote_settings: settings_hash
+    attr_reader local_settings: settings_hash
+    attr_reader pending_settings: settings_ary
+
+    attr_accessor active_stream_count: Integer
+
+    @stream_id: Integer
+    @active_stream_count: Integer
+    @last_activated_stream: Integer
+    @last_stream_id: Integer
+
+    @streams: Hash[Integer, Stream]
+    @streams_recently_closed: Hash[Integer, Stream]
+
+    @framer: Framer
+
+    @local_window_limit: Integer
+    @remote_window_limit: Integer
+
+    @compressor: Header::Compressor
+    @decompressor: Header::Decompressor
+    @error: Symbol?
+
+    @recv_buffer: String
+    @continuation: Array[frame]
+
+    @closed_since: Float?
+    @received_frame: bool
+
+    def closed?: () -> bool
+
+    def new_stream: (**untyped) -> Stream
+
+    def ping: (String) -> void
+            | (String) { () -> void } -> void
+
+    def goaway: (?Symbol, ?String) -> void
+
+    def window_update: (Integer increment) -> void
+
+    def settings: (settings_enum) -> void
+
+    def receive: (string data) -> void
+    alias << receive
+
+    def initialize: (?settings_hash) -> void
+
+    private
+
+    def send: (frame) -> void
+
+    def encode: (frame) -> Array[String]
+
+    def connection_frame?: (frame) -> bool
+
+    def connection_management: (frame) -> void
+
+    def ping_management: (frame) -> void
+
+    def validate_settings: (:client | :server, settings_enum) -> void
+
+    def connection_settings: (frame) -> void
+
+    def decode_headers: (frame) -> void
+
+    def encode_headers: (frame) -> Array[frame]
+
+    def activate_stream: (id: Integer, **untyped) -> Stream
+
+    def verify_stream_order: (Integer id) -> void
+
+    def verify_pseudo_headers: (frame) -> void
+
+    def _verify_pseudo_headers: (frame, Array[String]) -> void
+
+    def connection_error: (?Symbol error, ?msg: String?, ?e: StandardError?) -> void
+  end
+end

data/sig/emitter.rbs

@@ -0,0 +1,13 @@
+module HTTP2
+  module Emitter
+    def on: (Symbol event) { (*untyped) -> void } -> void
+
+    def once: (Symbol event) { (*untyped) -> void } -> void
+
+    def emit: (Symbol event, *untyped args) ?{ (*untyped) -> void } -> void
+
+    private
+
+    def listeners: (Symbol event)  -> Array[Proc]
+  end
+end

data/sig/error.rbs

@@ -0,0 +1,35 @@
+module HTTP2
+  module Error
+    def self?.types: () -> Hash[Symbol, singleton(Error)]
+
+    class Error < StandardError
+    end
+
+    class HandshakeError < Error
+    end
+
+    class ProtocolError < Error
+    end
+
+    class CompressionError < ProtocolError
+    end
+
+    class FlowControlError < ProtocolError
+    end
+
+    class InternalError < ProtocolError
+    end
+
+    class StreamClosed < Error
+    end
+
+    class ConnectionClosed < Error
+    end
+
+    class StreamLimitExceeded < Error
+    end
+
+    class FrameSizeError < Error
+    end
+  end
+end

data/sig/extensions.rbs

@@ -0,0 +1,5 @@
+module HTTP2
+  module PackingExtensions
+    def pack: (Array[Integer] array_to_pack, String template, buffer: String, ?offset: Integer) -> String
+  end
+end

data/sig/flow_buffer.rbs

@@ -0,0 +1,21 @@
+module HTTP2
+  module FlowBuffer
+    MAX_WINDOW_SIZE: Integer
+
+    def buffered_amount: () -> Integer
+
+    def flush: () -> void
+
+    private
+
+    def send_buffer: () -> FrameBuffer
+
+    def update_local_window: (frame) -> void
+
+    def calculate_window_update: (Integer) -> void
+
+    def send_data: (?frame? frame, ?bool encode) -> void
+
+    def process_window_update: (frame: frame, ?encode: bool) -> void
+  end
+end

data/sig/frame_buffer.rbs

@@ -0,0 +1,13 @@
+module HTTP2
+  class FrameBuffer
+    attr_reader bytesize: Integer
+
+    @buffer: Array[data_frame]
+
+    def <<: (data_frame) -> void
+
+    def empty?: () -> bool
+
+    def retrieve: (Integer) -> data_frame?
+  end
+end

data/sig/framer.rbs

@@ -0,0 +1,54 @@
+module HTTP2
+  class Framer
+    include PackingExtensions
+
+    DEFAULT_MAX_FRAME_SIZE: Integer
+
+    MAX_STREAM_ID: Integer
+
+    MAX_WINDOWINC: Integer
+
+    FRAME_TYPES: Hash[Symbol, Integer]
+
+    FRAME_TYPES_WITH_PADDING: Array[Symbol]
+
+    FRAME_FLAGS: Hash[Symbol, Hash[Symbol, Integer]]
+
+    DEFINED_SETTINGS: Hash[Symbol, Integer]
+
+    DEFINED_ERRORS: Hash[Symbol, Integer]
+
+    RBIT: Integer
+    RBYTE: Integer
+    EBIT: Integer
+    UINT32: String
+    UINT16: String
+    UINT8: String
+    HEADERPACK: String
+    FRAME_LENGTH_HISHIFT: Integer
+    FRAME_LENGTH_LOMASK: Integer
+
+    @local_max_frame_size: Integer
+    @remote_max_frame_size: Integer
+
+    attr_accessor local_max_frame_size: Integer
+
+    attr_accessor remote_max_frame_size: Integer
+
+    def common_header: (frame, buffer: String) -> String
+
+    def read_common_frame: (String) -> frame
+
+    def generate: (frame) -> String
+
+    def parse: (String) -> frame?
+
+    private
+
+    def initialize: (?Integer local_max_frame_size, ?Integer remote_max_frame_size) -> untyped
+
+    def pack_error: (Integer | Symbol error, buffer: String) -> String
+
+    def unpack_error: (Integer) -> (Symbol | Integer)
+  end
+end

data/sig/header/compressor.rbs

@@ -0,0 +1,27 @@
+module HTTP2
+  module Header
+    class Compressor
+      include PackingExtensions
+
+      @cc: EncodingContext
+
+      def table_size=: (Integer) -> void
+
+      def integer: (Integer, Integer, buffer: String, ?offset: Integer) -> String
+
+      def string: (String) -> String
+
+      def header: (header_command, ?String) -> String
+
+      def encode: (Enumerable[header_pair]) -> String
+
+      private
+
+      def initialize: (?context_hash options) -> void
+
+      def huffman_string: (String str) -> String
+
+      def plain_string: (String str) -> String
+    end
+  end
+end

data/sig/header/decompressor.rbs

@@ -0,0 +1,22 @@
+module HTTP2
+  module Header
+    class Decompressor
+      @cc: EncodingContext
+
+      def table_size=: (Integer) -> void
+
+      def integer: (String, Integer) -> Integer
+
+      def string: (String) -> String
+
+      def header: (String) -> header_command
+
+      def decode: (String, frame?) -> Array[header_pair]
+                | (String) -> Array[header_pair]
+      private
+
+      def initialize: (context_hash options) -> untyped
+                    | () -> untyped
+    end
+  end
+end

data/sig/header/encoding_context.rbs

@@ -0,0 +1,34 @@
+module HTTP2
+  module Header
+    class EncodingContext
+      STATIC_TABLE: Array[header_pair]
+
+      attr_reader table: Array[header_pair]
+
+      attr_reader options: context_hash
+
+      def dup: () -> EncodingContext
+
+      def dereference: (Integer) -> header_pair
+
+      def process: (header_command cmd) -> header_pair?
+
+      def encode: (_Each[header_pair]) -> Array[header_command]
+
+      def addcmd: (String name, String value) -> header_command
+
+      def table_size=: (Integer) -> void
+
+      def current_table_size: () -> Integer
+
+      private
+
+      def initialize: (context_hash options) -> untyped
+                    | () -> untyped
+
+      def add_to_table: (header_pair) -> void
+
+      def size_check: (header_pair?) -> bool
+    end
+  end
+end

data/sig/header/huffman.rbs

@@ -0,0 +1,9 @@
+module HTTP2
+  module Header
+    class Huffman
+      def encode: (String str) -> String
+
+      def decode: (String str) -> String
+    end
+  end
+end

data/sig/header.rbs

@@ -0,0 +1,27 @@
+module HTTP2
+  module Header
+    type header_key = :type | :name | :value | :index
+    type header_value = Integer | String | :indexed | :changetablesize | :incremental | :noindex | :neverindexed
+
+    #type context_hash = {
+    #  huffman?: (:always | :never | :shorter),
+    #  index?: (:all | :static | :never),
+    #  table_size?: Integer
+    #}
+    type context_hash = Hash[Symbol, Symbol | Integer]
+
+    type header_command = Hash[header_key, header_value]
+
+    HEADREP: Hash[Symbol, Hash[Symbol, Integer]]
+
+    NAIVE: Hash[Symbol, Symbol]
+    LINEAR: Hash[Symbol, Symbol]
+    STATIC: Hash[Symbol, Symbol]
+    SHORTER: Hash[Symbol, Symbol]
+    NAIVEH: Hash[Symbol, Symbol]
+    LINEARH: Hash[Symbol, Symbol]
+    STATICH: Hash[Symbol, Symbol]
+    SHORTERH: Hash[Symbol, Symbol]
+
+  end
+end

data/sig/next.rbs

@@ -0,0 +1,101 @@
+module HTTP2
+  VERSION: String
+
+  DEFAULT_FLOW_WINDOW: Integer
+
+  DEFAULT_HEADER_SIZE: Integer
+
+  DEFAULT_MAX_CONCURRENT_STREAMS: Integer
+
+  type settings_hash = Hash[Symbol, Integer]
+
+  type settings_ary = Array[settings_enum]
+
+  type settings_enum = Enumerable[[Symbol, Integer]]
+
+  SPEC_DEFAULT_CONNECTION_SETTINGS: settings_hash
+
+  DEFAULT_CONNECTION_SETTINGS: settings_hash
+
+  DEFAULT_WEIGHT: Integer
+
+  CONNECTION_PREFACE_MAGIC: String
+
+  REQUEST_MANDATORY_HEADERS: Array[String]
+
+  RESPONSE_MANDATORY_HEADERS: Array[String]
+
+  type header_pair = [string, string]
+
+  # # FRAMES
+  type frame_control_flags = Array[:end_headers | :end_stream]
+
+  # # HEADERS
+  # type headers_frame = {
+  #   type: :headers, flags: frame_control_flags, stream: Integer, payload: Enumerable[header_pair],
+  #   ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, ?padding: Integer
+  # }
+
+  # # DATA
+  type data_frame = { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String, padding: Integer }
+                  | { type: :data, flags: frame_control_flags, stream: Integer, length: Integer, payload: String }
+                  | { type: :data, flags: frame_control_flags, payload: String }
+
+  # # PUSH_PROMISE
+  # type push_promise_frame = { type: :push_promise, promise_stream: Integer, flags: frame_control_flags, stream: Integer, ?method: Symbol, ?trailer: Array[String], ?content_length: Integer, payload: Enumerable[header_pair], ?padding: Integer }
+
+  # # SETTINGS
+  # type settings_frame = { type: :settings, stream: 0, payload: Array[[Symbol | Integer, Integer]] }
+
+  # # WINDOW_UPDATE
+  # type window_update_frame = { type: :window_update, stream: Integer, increment: Integer }
+
+  # # PRIORITY
+  type priority_frame = { type: :priority, stream: Integer, dependency: Integer, exclusive: bool, weight: Integer }
+
+  # # ALTSVC
+  # type altsvc_frame = { type: :altsvc, stream: 0, max_age: Integer, port: Integer, proto: "String", host: String }
+
+  # # ORIGIN
+  # type origin_frame = { type: :origin, stream: 0, origin: Array[String] }
+
+  # # PING
+  # type ping_frame = { type: :ping, payload: String, length: Integer }
+
+  # # GOAWAY
+  # type goaway_frame = { type: :goaway, stream: 0, last_stream: Integer, error: Symbol? }
+
+  # type frame = headers_frame | data_frame | push_promise_frame |
+  #              settings_frame | window_update_frame | priority_frame | altsvc_frame |
+  #              origin_frame | ping_frame | goaway_frame
+
+  type frame_key = :type | :flags | :stream | :padding | :ignore |
+                   # headers
+                   :method | :trailer | :content_length | :status |
+                   # data, settings, ping
+                   :payload | :length |
+                   # promise
+                   :promise_stream |
+                   # window_update
+                   :increment |
+                   # priority
+                   :dependency | :exclusive | :weight |
+                   # altsvc
+                   :max_age | :port | :proto | :host |
+                   # origin
+                   :origin |
+                   # goaway
+                   :last_stream | :error
+
+  type frame_value = Integer |
+                     Symbol | # type (:data, :headers)
+                     Array[Symbol] |
+                     String |
+                     bool |
+                     Array[String] |
+                     Array[[Symbol | Integer, Integer]] |
+                     Enumerable[header_pair] |
+                     nil
+
+  type frame = Hash[frame_key, frame_value]
+end

data/sig/server.rbs

@@ -0,0 +1,12 @@
+module HTTP2
+  class Server < Connection
+
+    def upgrade: (String settings, Enumerable[header_pair] headers, String body) -> void
+
+    def origin_set=: (Array[_ToS]) -> void
+
+    private
+
+    def promise: (Stream parent, Enumerable[header_pair] headers, Array[Symbol] flags) { (Stream) -> void } -> void
+  end
+end

data/sig/stream.rbs

@@ -0,0 +1,91 @@
+module HTTP2
+  class Stream
+    include FlowBuffer
+    include Emitter
+
+    attr_reader id: Integer
+    attr_reader state: Symbol
+    attr_reader parent: Stream?
+    attr_reader weight: Integer
+    attr_reader dependency: Integer
+    attr_reader remote_window: Integer
+    attr_reader local_window: Integer
+    attr_reader closed: Symbol?
+
+    @connection: Connection
+    @local_window_max_size: Integer
+    @error: bool
+    @_method: String?
+    @_content_length: Integer?
+    @_status_code: Integer?
+    @_waiting_on_trailers: bool
+    @received_data: bool
+    @activated: bool
+
+    alias window local_window
+
+    def closed?: () -> bool
+
+    def receive: (frame) -> void
+
+    alias << receive
+
+    def verify_trailers: (frame) -> void
+
+    def calculate_content_length: (Integer?) -> void
+
+    def send: (frame) -> void
+
+    def headers: (Enumerable[header_pair] headers, ?end_headers: bool, ?end_stream: bool) -> void
+
+    def promise: (Enumerable[header_pair] headers, ?end_headers: bool) { (Stream) -> void } -> void
+
+    def reprioritize: (?weight: Integer, ?dependency: Integer, ?exclusive: bool) -> void
+
+    def data: (String payload, ?end_stream: bool) -> void
+
+    def chunk_data: (String payload, Integer max_size) { (String) -> void } -> String
+
+    def close: (Symbol error) -> void
+             | () -> void
+
+    def cancel: () -> void
+
+    def refuse: () -> void
+
+    def window_update: (Integer increment) -> void
+
+    private
+
+    def initialize: (
+      connection: Connection,
+      id: Integer,
+      ?weight: Integer,
+      ?dependency: Integer,
+      ?exclusive: bool,
+      ?parent: Stream?,
+      ?state: Symbol
+    ) -> untyped
+
+    def transition: (frame, bool sending) -> void
+
+    def event: (Symbol newstate) -> void
+
+    def activate_stream_in_conn: () -> void
+
+    def close_stream_in_conn: (*untyped) -> void
+
+    def complete_transition: (frame) -> void
+
+    def process_priority: ({weight: Integer, dependency: Integer, exclusive: bool}) -> void
+
+    def end_frame?: () -> bool
+
+    def stream_error: (Symbol error, ?msg: String?) -> void
+                    | () -> void
+
+    alias error stream_error
+
+    def manage_state: (frame) { () -> void } -> void
+  end
+end