Expose options (Huffman encoding for now) (#12)

Author: mtrudel

lib/hpax.ex

@@ -43,9 +43,10 @@ defmodule HPAX do
       encoding_context = HPAX.new(4096)
 
   """
-  @spec new(non_neg_integer()) :: Table.t()
-  def new(max_table_size) when is_integer(max_table_size) and max_table_size >= 0 do
-    Table.new(max_table_size)
+  @spec new(non_neg_integer(), [Table.option()]) :: Table.t()
+  def new(max_table_size, options \\ [])
+      when is_integer(max_table_size) and max_table_size >= 0 do
+    Table.new(max_table_size, options)
   end
 
   @doc """
@@ -255,28 +256,32 @@ defmodule HPAX do
 
   defp encode_headers([{action, name, value} | rest], table, acc)
        when action in @valid_header_actions and is_binary(name) and is_binary(value) do
+    huffman? = table.huffman == :always
+
     {encoded, table} =
       case Table.lookup_by_header(table, name, value) do
         {:full, index} ->
           {encode_indexed_header(index), table}
 
         {:name, index} when action == :store ->
-          {encode_literal_header_with_indexing(index, value), Table.add(table, name, value)}
+          {encode_literal_header_with_indexing(index, value, huffman?),
+           Table.add(table, name, value)}
 
         {:name, index} when action in [:store_name, :no_store] ->
-          {encode_literal_header_without_indexing(index, value), table}
+          {encode_literal_header_without_indexing(index, value, huffman?), table}
 
         {:name, index} when action == :never_store ->
-          {encode_literal_header_never_indexed(index, value), table}
+          {encode_literal_header_never_indexed(index, value, huffman?), table}
 
         :not_found when action in [:store, :store_name] ->
-          {encode_literal_header_with_indexing(name, value), Table.add(table, name, value)}
+          {encode_literal_header_with_indexing(name, value, huffman?),
+           Table.add(table, name, value)}
 
         :not_found when action == :no_store ->
-          {encode_literal_header_without_indexing(name, value), table}
+          {encode_literal_header_without_indexing(name, value, huffman?), table}
 
         :not_found when action == :never_store ->
-          {encode_literal_header_never_indexed(name, value), table}
+          {encode_literal_header_never_indexed(name, value, huffman?), table}
       end
 
     encode_headers(rest, table, [acc, encoded])
@@ -286,27 +291,27 @@ defmodule HPAX do
     <<1::1, Types.encode_integer(index, 7)::bitstring>>
   end
 
-  defp encode_literal_header_with_indexing(index, value) when is_integer(index) do
-    [<<1::2, Types.encode_integer(index, 6)::bitstring>>, Types.encode_binary(value, false)]
+  defp encode_literal_header_with_indexing(index, value, huffman) when is_integer(index) do
+    [<<1::2, Types.encode_integer(index, 6)::bitstring>>, Types.encode_binary(value, huffman)]
   end
 
-  defp encode_literal_header_with_indexing(name, value) when is_binary(name) do
-    [<<1::2, 0::6>>, Types.encode_binary(name, false), Types.encode_binary(value, false)]
+  defp encode_literal_header_with_indexing(name, value, huffman) when is_binary(name) do
+    [<<1::2, 0::6>>, Types.encode_binary(name, huffman), Types.encode_binary(value, huffman)]
   end
 
-  defp encode_literal_header_without_indexing(index, value) when is_integer(index) do
-    [<<0::4, Types.encode_integer(index, 4)::bitstring>>, Types.encode_binary(value, false)]
+  defp encode_literal_header_without_indexing(index, value, huffman) when is_integer(index) do
+    [<<0::4, Types.encode_integer(index, 4)::bitstring>>, Types.encode_binary(value, huffman)]
   end
 
-  defp encode_literal_header_without_indexing(name, value) when is_binary(name) do
-    [<<0::4, 0::4>>, Types.encode_binary(name, false), Types.encode_binary(value, false)]
+  defp encode_literal_header_without_indexing(name, value, huffman) when is_binary(name) do
+    [<<0::4, 0::4>>, Types.encode_binary(name, huffman), Types.encode_binary(value, huffman)]
   end
 
-  defp encode_literal_header_never_indexed(index, value) when is_integer(index) do
-    [<<1::4, Types.encode_integer(index, 4)::bitstring>>, Types.encode_binary(value, false)]
+  defp encode_literal_header_never_indexed(index, value, huffman) when is_integer(index) do
+    [<<1::4, Types.encode_integer(index, 4)::bitstring>>, Types.encode_binary(value, huffman)]
   end
 
-  defp encode_literal_header_never_indexed(name, value) when is_binary(name) do
-    [<<1::4, 0::4>>, Types.encode_binary(name, false), Types.encode_binary(value, false)]
+  defp encode_literal_header_never_indexed(name, value, huffman) when is_binary(name) do
+    [<<1::4, 0::4>>, Types.encode_binary(name, huffman), Types.encode_binary(value, huffman)]
   end
 end

lib/hpax/table.ex

@@ -3,18 +3,23 @@ defmodule HPAX.Table do
 
   defstruct [
     :max_table_size,
+    :huffman,
     entries: [],
     size: 0,
     length: 0
   ]
 
   @type t() :: %__MODULE__{
           max_table_size: non_neg_integer(),
+          huffman: huffman_strategy(),
           entries: [{binary(), binary()}],
           size: non_neg_integer(),
           length: non_neg_integer()
         }
 
+  @type huffman_strategy() :: :always | :never
+  @type option :: {:huffman, huffman_strategy()}
+
   @static_table [
     {":authority", nil},
     {":method", "GET"},
@@ -88,9 +93,10 @@ defmodule HPAX.Table do
   The maximum size is not the maximum number of entries but rather the maximum size as defined in
   http://httpwg.org/specs/rfc7541.html#maximum.table.size.
   """
-  @spec new(non_neg_integer()) :: t()
-  def new(max_table_size) do
-    %__MODULE__{max_table_size: max_table_size}
+  @spec new(non_neg_integer(), [option()]) :: t()
+  def new(max_table_size, options \\ []) do
+    huffman = Keyword.get(options, :huffman, :always)
+    %__MODULE__{max_table_size: max_table_size, huffman: huffman}
   end
 
   @doc """

test/hpax_test.exs

@@ -21,6 +21,46 @@ defmodule HPAXTest do
     assert headers == [{"custom-key", "custom-header"}]
   end
 
+  # https://http2.github.io/http2-spec/compression.html#rfc.section.C.3.1
+  test "encode/2 with a literal example from the spec" do
+    table = HPAX.new(1000, huffman: :never)
+
+    headers = [
+      {:store, ":method", "GET"},
+      {:store, ":scheme", "http"},
+      {:store, ":path", "/"},
+      {:store, ":authority", "www.example.com"}
+    ]
+
+    assert {encoded, %HPAX.Table{}} = HPAX.encode(headers, table)
+
+    expected =
+      <<0x82, 0x86, 0x84, 0x41, 0x0F, 0x77, 0x77, 0x77, 0x2E, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C,
+        0x65, 0x2E, 0x63, 0x6F, 0x6D>>
+
+    assert IO.iodata_to_binary(encoded) == expected
+  end
+
+  # https://http2.github.io/http2-spec/compression.html#rfc.section.C.4.1
+  test "encode/2 with a Huffman example from the spec" do
+    table = HPAX.new(1000)
+
+    headers = [
+      {:store, ":method", "GET"},
+      {:store, ":scheme", "http"},
+      {:store, ":path", "/"},
+      {:store, ":authority", "www.example.com"}
+    ]
+
+    assert {encoded, %HPAX.Table{}} = HPAX.encode(headers, table)
+
+    expected =
+      <<0x82, 0x86, 0x84, 0x41, 0x8C, 0xF1, 0xE3, 0xC2, 0xE5, 0xF2, 0x3A, 0x6B, 0xA0, 0xAB, 0x90,
+        0xF4, 0xFF>>
+
+    assert IO.iodata_to_binary(encoded) == expected
+  end
+
   test "manually doing operations on the table that property-based testing would be " <>
          "so much better at doing :( we need stateful testing folks" do
     enc_table = HPAX.new(1000)