http-2 0.6.3 → 0.7.0

data/lib/http/2/server.rb

@@ -22,11 +22,12 @@ module HTTP2
   class Server < Connection
 
     # Initialize new HTTP 2.0 server object.
-    def initialize(*args)
+    def initialize(**settings)
       @stream_id    = 2
-      @state        = :new
-      @compressor   = Header::Compressor.new(:response)
-      @decompressor = Header::Decompressor.new(:request)
+      @state        = :waiting_magic
+
+      @local_role   = :server
+      @remote_role  = :client
 
       super
     end

data/lib/http/2/stream.rb

@@ -24,7 +24,7 @@ module HTTP2
   #   |      |      ,-------|:active |-------.      |      |
   #   |      | H   /   ES   |        |   ES   \   H |      |
   #   |      v    v         +--------+         v    v      |
-  #   |   +-----------+          |          +-_---------+  |
+  #   |   +-----------+          |          +-----------+  |
   #   |   |:half_close|          |          |:half_close|  |
   #   |   |  (remote) |          |          |  (local)  |  |
   #   |   +-----------+          |          +-----------+  |
@@ -49,10 +49,13 @@ module HTTP2
     attr_reader :parent
 
     # Stream priority as set by initiator.
-    attr_reader :priority
+    attr_reader :weight
+    attr_reader :dependency
 
     # Size of current stream flow control window.
-    attr_reader :window
+    attr_reader :local_window
+    attr_reader :remote_window
+    alias :window :local_window
 
     # Reason why connection was closed.
     attr_reader :closed
@@ -64,20 +67,26 @@ module HTTP2
     # will emit new stream objects, when new stream frames are received.
     #
     # @param id [Integer]
-    # @param priority [Integer]
+    # @param weight [Integer]
+    # @param dependency [Integer]
+    # @param exclusive [Boolean]
     # @param window [Integer]
     # @param parent [Stream]
-    def initialize(id, priority, window, parent = nil)
-      @id = id
-      @priority = priority
-      @window = window
+    def initialize(connection: nil, id: nil, weight: 16, dependency: 0, exclusive: false, parent: nil)
+      @connection = connection or raise ArgumentError.new("missing mandatory argument connection")
+      @id = id                 or raise ArgumentError.new("missing mandatory argument id")
+      @weight = weight
+      @dependency = dependency
+      process_priority({weight: weight, stream_dependency: dependency, exclusive: exclusive})
+      @remote_window = connection.remote_settings[:settings_initial_window_size]
       @parent = parent
       @state  = :idle
       @error  = false
       @closed = false
       @send_buffer = []
 
-      on(:window) { |v| @window = v }
+      on(:window) { |v| @remote_window = v }
+      on(:local_window) { |v| @local_window = v }
     end
 
     # Processes incoming HTTP 2.0 frames. The frames must be decoded upstream.
@@ -88,19 +97,17 @@ module HTTP2
 
       case frame[:type]
       when :data
+        # TODO: when receiving DATA, keep track of local_window.
         emit(:data, frame[:payload]) if !frame[:ignore]
       when :headers, :push_promise
-        if frame[:payload].is_a? Array
-          emit(:headers, Hash[*frame[:payload].flatten]) if !frame[:ignore]
-        else
-          emit(:headers, frame[:payload]) if !frame[:ignore]
-        end
+        emit(:headers, frame[:payload]) if !frame[:ignore]
       when :priority
-        @priority = frame[:priority]
-        emit(:priority, @priority)
+        process_priority(frame)
       when :window_update
-        @window += frame[:increment]
+        @remote_window += frame[:increment]
         send_data
+      when :altsvc, :blocked
+        emit(frame[:type], frame)
       end
 
       complete_transition(frame)
@@ -116,7 +123,7 @@ module HTTP2
       transition(frame, true)
       frame[:stream] ||= @id
 
-      @priority = frame[:priority] if frame[:type] == :priority
+      process_priority(frame) if frame[:type] == :priority
 
       if frame[:type] == :data
         send_data(frame)
@@ -129,7 +136,7 @@ module HTTP2
 
     # Sends a HEADERS frame containing HTTP response headers.
     #
-    # @param headers [Hash]
+    # @param headers [Array or Hash] Array of key-value pairs or Hash
     # @param end_headers [Boolean] indicates that no more headers will be sent
     # @param end_stream [Boolean] indicates that no payload will be sent
     def headers(headers, end_headers: true, end_stream: false)
@@ -140,20 +147,21 @@ module HTTP2
       send({type: :headers, flags: flags, payload: headers.to_a})
     end
 
-    def promise(headers, end_push_promise: true, &block)
+    def promise(headers, end_headers: true, &block)
       raise Exception.new("must provide callback") if !block_given?
 
-      flags = end_push_promise ? [:end_push_promise] : []
+      flags = end_headers ? [:end_headers] : []
       emit(:promise, self, headers, flags, &block)
     end
 
     # Sends a PRIORITY frame with new stream priority value (can only be
     # performed by the client).
     #
-    # @param p [Integer] new stream priority value
-    def reprioritize(p)
+    # @param weight [Integer] new stream weight value
+    # @param dependency [Integer] new stream dependency stream
+    def reprioritize(weight: 16, dependency: 0, exclusive: false)
       stream_error if @id.even?
-      send({type: :priority, priority: p})
+      send({type: :priority, weight: weight, stream_dependency: dependency, exclusive: exclusive})
     end
 
     # Sends DATA frame containing response payload.
@@ -164,8 +172,11 @@ module HTTP2
       flags = []
       flags << :end_stream if end_stream
 
-      while payload.bytesize > MAX_FRAME_SIZE do
-        chunk = payload.slice!(0, MAX_FRAME_SIZE)
+      # Split data according to each frame is smaller enough
+      # TODO: consider padding?
+      max_size = @connection.remote_settings[:settings_max_frame_size]
+      while payload.bytesize > max_size do
+        chunk = payload.slice!(0, max_size)
         send({type: :data, payload: chunk})
       end
 
@@ -344,8 +355,11 @@ module HTTP2
       # frame bearing the END_STREAM flag is sent.
       when :half_closed_local
         if sending
-          if frame[:type] == :rst_stream
+          case frame[:type]
+          when :rst_stream
             event(:local_rst)
+          when :priority
+            process_priority(frame)
           else
             stream_error
           end
@@ -354,8 +368,10 @@ module HTTP2
           when :data, :headers, :continuation
             event(:remote_closed) if end_stream?(frame)
           when :rst_stream then event(:remote_rst)
-          when :window_update, :priority
-            frame[:igore] = true
+          when :priority
+            process_priority(frame)
+          when :window_update
+            frame[:ignore] = true
           end
         end
 
@@ -380,6 +396,8 @@ module HTTP2
           case frame[:type]
           when :rst_stream then event(:remote_rst)
           when :window_update then frame[:ignore] = true
+          when :priority
+            process_priority(frame)
           else stream_error(:stream_closed); end
         end
 
@@ -407,15 +425,21 @@ module HTTP2
         if sending
           case frame[:type]
           when :rst_stream then # ignore
+          when :priority   then
+            process_priority(frame)
           else
             stream_error(:stream_closed) if !(frame[:type] == :rst_stream)
           end
         else
-          case @closed
-          when :remote_rst, :remote_closed
-            stream_error(:stream_closed) if !(frame[:type] == :rst_stream)
-          when :local_rst, :local_closed
-            frame[:ignore] = true
+          if frame[:type] == :priority
+            process_priority(frame)
+          else
+            case @closed
+            when :remote_rst, :remote_closed
+              stream_error(:stream_closed) if !(frame[:type] == :rst_stream)
+            when :local_rst, :local_closed
+              frame[:ignore] = true
+            end
           end
         end
       end
@@ -455,6 +479,20 @@ module HTTP2
       end
     end
 
+    def process_priority(frame)
+      @weight = frame[:weight]
+      @dependency = frame[:stream_dependency]
+      emit(:priority,
+           weight:      frame[:weight],
+           dependency:  frame[:stream_dependency],
+           exclusive:   frame[:exclusive])
+      # TODO: implement dependency tree housekeeping
+      #   Latest draft defines a fairly complex priority control.
+      #   See https://tools.ietf.org/html/draft-ietf-httpbis-http2-14#section-5.3
+      #   We currently have no prioritization among streams.
+      #   We should add code here.
+    end
+
     def end_stream?(frame)
       case frame[:type]
       when :data, :headers, :continuation
@@ -469,6 +507,5 @@ module HTTP2
       klass = error.to_s.split('_').map(&:capitalize).join
       raise Error.const_get(klass).new(msg)
     end
-
   end
 end

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end

data/lib/tasks/generate_huffman_table.rb

@@ -0,0 +1,160 @@
+desc "Generate Huffman precompiled table in huffman_statemachine.rb"
+task :generate_table do
+  HuffmanTable::Node.generate_state_table
+end
+
+require_relative '../http/2/huffman'
+
+# @private
+module HuffmanTable
+  BITS_AT_ONCE = HTTP2::Header::Huffman::BITS_AT_ONCE
+  EOS          = 256
+
+  class Node
+    attr_accessor :next, :emit, :final, :depth
+    attr_accessor :transitions
+    attr_accessor :id
+    @@id = 0
+    def initialize(depth)
+      @next = [nil, nil]
+      @id = @@id
+      @@id += 1
+      @final = false
+      @depth = depth
+    end
+    def add(code, len, chr)
+      chr == EOS && @depth <= 7 and self.final = true
+      if len == 0
+        @emit = chr
+      else
+        bit = (code & (1 << (len - 1))) == 0 ? 0 : 1
+        node = @next[bit] ||= Node.new(@depth + 1)
+        node.add(code, len - 1, chr)
+      end
+    end
+
+    class Transition
+      attr_accessor :emit, :node
+      def initialize(emit, node)
+        @emit = emit
+        @node = node
+      end
+    end
+
+    def self.generate_tree
+      @root = new(0)
+      HTTP2::Header::Huffman::CODES.each_with_index do |c, chr|
+        code, len = c
+        @root.add(code, len, chr)
+      end
+      puts "#{@@id} nodes"
+      @root
+    end
+
+    def self.generate_machine
+      generate_tree
+      togo = Set[@root]
+      @states = Set[@root]
+
+      until togo.empty?
+        node = togo.first
+        togo.delete(node)
+
+        next if node.transitions
+        node.transitions = Array[1 << BITS_AT_ONCE]
+
+        (1 << BITS_AT_ONCE).times do |input|
+          n = node
+          emit = ''
+          (BITS_AT_ONCE - 1).downto(0) do |i|
+            bit = (input & (1 << i)) == 0 ? 0 : 1
+            n = n.next[bit]
+            if n.emit
+              if n.emit == EOS
+                emit = EOS      # cause error on decoding
+              else
+                emit << n.emit.chr('binary') unless emit == EOS
+              end
+              n = @root
+            end
+          end
+          node.transitions[input] = Transition.new(emit, n)
+          togo << n
+          @states << n
+        end
+      end
+      puts "#{@states.size} states"
+      @root
+    end
+
+    def self.generate_state_table
+      generate_machine
+      state_id = {}
+      id_state = {}
+      state_id[@root] = 0
+      id_state[0] = @root
+      max_final = 0
+      id = 1
+      (@states - [@root]).sort_by{|s|s.final ? 0 : 1}.each do |s|
+        state_id[s] = id
+        id_state[id] = s
+        max_final = id if s.final
+        id += 1
+      end
+
+      File.open(File.expand_path("../http/2/huffman_statemachine.rb", File.dirname(__FILE__)), "w") do |f|
+        f.print <<HEADER
+# Machine generated Huffman decoder state machine.
+# DO NOT EDIT THIS FILE.
+
+# The following task generates this file.
+#   rake generate_huffman_table
+
+module HTTP2
+  module Header
+    class Huffman
+      # :nodoc:
+      MAX_FINAL_STATE = #{max_final}
+      MACHINE = [
+HEADER
+        id.times do |i|
+          n = id_state[i]
+          f.print "        ["
+          (1 << BITS_AT_ONCE).times do |t|
+            emit = n.transitions[t].emit
+            emit == EOS or emit = emit.dup.force_encoding('binary')
+            f.print %Q/[#{emit == '' ? "nil" : emit.inspect},#{state_id[n.transitions[t].node]}],/
+          end
+          f.print "],\n"
+        end
+        f.print <<TAILER
+      ]
+    end
+  end
+end
+TAILER
+      end
+    end
+
+    def self.root
+      @root
+    end
+
+    # Test decoder
+    def self.decode(input)
+      emit = ''
+      n = root
+      nibbles = input.unpack("C*").flat_map{|b| [((b & 0xf0) >> 4), b & 0xf]}
+      until nibbles.empty?
+        nb = nibbles.shift
+        t = n.transitions[nb]
+        emit << t.emit
+        n = t.node
+      end
+      unless n.final && nibbles.all?{|x| x == 0xf}
+        puts "len = #{emit.size} n.final = #{n.final} nibbles = #{nibbles}"
+      end
+      emit
+    end
+  end
+end

data/spec/client_spec.rb

@@ -17,20 +17,20 @@ describe HTTP2::Client do
       @client.on(:frame) { |bytes| frames << bytes }
       @client.ping("12345678")
 
-      frames[0].should eq CONNECTION_HEADER
+      frames[0].should eq CONNECTION_PREFACE_MAGIC
       f.parse(frames[1])[:type].should eq :settings
     end
 
     it "should initialize client with custom connection settings" do
       frames = []
 
-      @client = Client.new(streams: 200)
+      @client = Client.new(:settings_max_concurrent_streams => 200)
       @client.on(:frame) { |bytes| frames << bytes }
       @client.ping("12345678")
 
       frame = f.parse(frames[1])
       frame[:type].should eq :settings
-      frame[:payload][:settings_max_concurrent_streams].should eq 200
+      frame[:payload].should include([:settings_max_concurrent_streams, 200])
     end
   end
 

data/spec/compressor_spec.rb

@@ -2,8 +2,8 @@ require "helper"
 
 describe HTTP2::Header do
 
-  let(:c) { Compressor.new :request }
-  let(:d) { Decompressor.new :response }
+  let(:c) { Compressor.new }
+  let(:d) { Decompressor.new }
 
   context "literal representation" do
     context "integer" do
@@ -33,28 +33,39 @@ describe HTTP2::Header do
     end
 
     context "string" do
-      it "should handle ascii codepoints" do
-        ascii = "abcdefghij"
-        str = c.string(ascii)
-
-        buf = Buffer.new(str+"trailer")
-        d.string(buf).should eq ascii
-      end
-
-      it "should handle utf-8 codepoints" do
-        utf8 = "éáűőúöüó€"
-        str = c.string(utf8)
-
-        buf = Buffer.new(str+"trailer")
-        d.string(buf).should eq utf8
+      [ ['with huffman',    :always, 0x80 ],
+        ['without huffman', :never,  0] ].each do |desc, option, msb|
+        let (:trailer) { "trailer" }
+
+        [
+          ['ascii codepoints', 'abcdefghij'],
+          ['utf-8 codepoints', 'éáűőúöüó€'],
+          ['long utf-8 strings', 'éáűőúöüó€'*100],
+        ].each do |datatype, plain|
+          it "should handle #{datatype} #{desc}" do
+            # NOTE: don't put this new in before{} because of test case shuffling
+            @c = Compressor.new(huffman: option)
+            str = @c.string(plain)
+            (str.getbyte(0) & 0x80).should eq msb
+
+            buf = Buffer.new(str + trailer)
+            d.string(buf).should eq plain
+            buf.should eq trailer
+          end
+        end
       end
-
-      it "should handle long utf-8 strings" do
-        utf8 = "éáűőúöüó€"*100
-        str = c.string(utf8)
-
-        buf = Buffer.new(str+"trailer")
-        d.string(buf).should eq utf8
+      context "choosing shorter representation" do
+        [ ['日本語', :plain],
+          ['200', :huffman],
+          ['xq', :plain],   # prefer plain if equal size
+        ].each do |string, choice|
+          before { @c = Compressor.new(huffman: :shorter) }
+
+          it "should return #{choice} representation" do
+            wire = @c.string(string)
+            (wire.getbyte(0) & 0x80).should eq (choice == :plain ? 0 : 0x80)
+          end
+        end
       end
     end
   end
@@ -62,332 +73,462 @@ describe HTTP2::Header do
   context "header representation" do
     it "should handle indexed representation" do
       h = {name: 10, type: :indexed}
-      d.header(c.header(h)).should eq h
+      wire = c.header(h)
+      (wire.readbyte(0) & 0x80).should eq 0x80
+      (wire.readbyte(0) & 0x7f).should eq h[:name] + 1
+      d.header(wire).should eq h
+    end
+    it "should raise when decoding indexed representation with index zero" do
+      h = {name: 10, type: :indexed}
+      wire = c.header(h)
+      wire[0] = 0x80.chr('binary')
+      expect { d.header(wire) }.to raise_error CompressionError
     end
 
     context "literal w/o indexing representation" do
       it "should handle indexed header" do
         h = {name: 10, value: "my-value", type: :noindex}
-        d.header(c.header(h)).should eq h
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xf0).should eq 0x0
+        (wire.readbyte(0) & 0x0f).should eq h[:name] + 1
+        d.header(wire).should eq h
       end
 
       it "should handle literal header" do
         h = {name: "x-custom", value: "my-value", type: :noindex}
-        d.header(c.header(h)).should eq h
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xf0).should eq 0x0
+        (wire.readbyte(0) & 0x0f).should eq 0
+        d.header(wire).should eq h
       end
     end
 
     context "literal w/ incremental indexing" do
       it "should handle indexed header" do
         h = {name: 10, value: "my-value", type: :incremental}
-        d.header(c.header(h)).should eq h
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xc0).should eq 0x40
+        (wire.readbyte(0) & 0x3f).should eq h[:name] + 1
+        d.header(wire).should eq h
       end
 
       it "should handle literal header" do
         h = {name: "x-custom", value: "my-value", type: :incremental}
-        d.header(c.header(h)).should eq h
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xc0).should eq 0x40
+        (wire.readbyte(0) & 0x3f).should eq 0
+        d.header(wire).should eq h
       end
     end
 
-    context "literal w/ substitution indexing" do
+    context "literal never indexed" do
       it "should handle indexed header" do
-        h = {name: 1, value: "my-value", index: 10, type: :substitution}
-        d.header(c.header(h)).should eq h
+        h = {name: 10, value: "my-value", type: :neverindexed}
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xf0).should eq 0x10
+        (wire.readbyte(0) & 0x0f).should eq h[:name] + 1
+        d.header(wire).should eq h
       end
 
       it "should handle literal header" do
-        h = {name: "x-new", value: "my-value", index: 10, type: :substitution}
-        d.header(c.header(h)).should eq h
+        h = {name: "x-custom", value: "my-value", type: :neverindexed}
+        wire = c.header(h)
+        (wire.readbyte(0) & 0xf0).should eq 0x10
+        (wire.readbyte(0) & 0x0f).should eq 0
+        d.header(wire).should eq h
       end
     end
   end
 
-  context "differential coding" do
-    context "shared compression context" do
-      before(:each) { @cc = EncodingContext.new(:request) }
-
-      it "should be initialized with pre-defined headers" do
-        cc = EncodingContext.new(:request)
-        cc.table.size.should eq 30
-
-        cc = EncodingContext.new(:response)
-        cc.table.size.should eq 30
-      end
-
-      it "should be initialized with empty working set" do
-        @cc.refset.should be_empty
-      end
-
-      it "should update working set based on prior state" do
-        @cc.refset.should be_empty
-
-        @cc.process({name: 0, type: :indexed})
-        @cc.refset.should eq [[0, [":scheme", "http"]]]
+  context "shared compression context" do
+    before(:each) { @cc = EncodingContext.new }
 
-        @cc.process({name: 0, type: :indexed})
-        @cc.refset.should be_empty
-      end
-
-      context "processing" do
-        it "should toggle index representation headers in working set" do
-          @cc.process({name: 0, type: :indexed})
-          @cc.refset.first.should eq [0, [":scheme", "http"]]
-
-          @cc.process({name: 0, type: :indexed})
-          @cc.refset.should be_empty
-        end
+    it "should be initialized with empty headers" do
+      cc = EncodingContext.new
+      cc.table.should be_empty
+    end
 
-        context "no indexing" do
+    context "processing" do
+      [ ["no indexing", :noindex],
+        ["never indexed", :neverindexed]].each do |desc, type|
+        context "#{desc}" do
           it "should process indexed header with literal value" do
-            original_table = @cc.table
+            original_table = @cc.table.dup
 
-            emit = @cc.process({name: 3, value: "/path", type: :noindex})
+            emit = @cc.process({name: 4, value: "/path", type: type})
             emit.should eq [":path", "/path"]
-            @cc.refset.should be_empty
-            @cc.table.should eq original_table
-          end
-
-          it "should process indexed header with default value" do
-            original_table = @cc.table
-
-            emit = @cc.process({name: 3, type: :noindex})
-            emit.should eq [":path", "/"]
             @cc.table.should eq original_table
           end
 
           it "should process literal header with literal value" do
-            original_table = @cc.table
+            original_table = @cc.table.dup
 
-            emit = @cc.process({name: "x-custom", value: "random", type: :noindex})
+            emit = @cc.process({name: "x-custom", value: "random", type: type})
             emit.should eq ["x-custom", "random"]
-            @cc.refset.should be_empty
             @cc.table.should eq original_table
           end
         end
+      end
 
-        context "incremental indexing" do
-          it "should process literal header with literal value" do
-            original_table = @cc.table.dup
+      context "incremental indexing" do
+        it "should process indexed header with literal value" do
+          original_table = @cc.table.dup
 
-            @cc.process({name: "x-custom", value: "random", type: :incremental})
-            @cc.refset.first.should eq [original_table.size, ["x-custom", "random"]]
-            (@cc.table - original_table).should eq [["x-custom", "random"]]
-          end
+          emit = @cc.process({name: 4, value: "/path", type: :incremental})
+          emit.should eq [":path", "/path"]
+          (@cc.table - original_table).should eq [[":path", "/path"]]
         end
 
-        context "substitution indexing" do
-          it "should process literal header with literal value" do
-            original_table = @cc.table.dup
-            idx = original_table.size-1
-
-            @cc.process({
-              name: "x-custom", value: "random",
-              index: idx, type: :substitution
-            })
+        it "should process literal header with literal value" do
+          original_table = @cc.table.dup
 
-            @cc.refset.first.should eq [idx, ["x-custom", "random"]]
-            (@cc.table - original_table).should eq [["x-custom", "random"]]
-            (original_table - @cc.table).should eq [["via", ""]]
-          end
-
-          it "should raise error on invalid substitution index" do
-            lambda {
-              @cc.process({
-                name: "x-custom", value: "random",
-                index: 1000, type: :substitution
-              })
-            }.should raise_error(HeaderException)
-          end
+          @cc.process({name: "x-custom", value: "random", type: :incremental})
+          (@cc.table - original_table).should eq [["x-custom", "random"]]
         end
+      end
 
-        context "size bounds" do
-          it "should drop headers from beginning of table" do
-            cc = EncodingContext.new(:request, 2048)
-            original_table = cc.table.dup
-            original_size = original_table.join.bytesize +
-                            original_table.size * 32
-
-            cc.process({
-              name: "x-custom",
-              value: "a" * (2048 - original_size),
-              type: :incremental
-            })
-
-            cc.table.last[0].should eq "x-custom"
-            cc.table.size.should eq original_table.size
-           end
-
-          it "should prepend on dropped substitution index" do
-            cc = EncodingContext.new(:request, 2048)
-            original_table = cc.table.dup
-            original_size = original_table.join.bytesize +
-                            original_table.size * 32
-
-            cc.process({
-              name: "x-custom",
-              value: "a" * (2048 - original_size),
-              index: 0, type: :substitution
-            })
-
-            cc.table[0][0].should eq "x-custom"
-            cc.table[1][0].should eq ":scheme"
+      context "size bounds" do
+        it "should drop headers from end of table" do
+          cc = EncodingContext.new(table_size: 2048)
+          cc.instance_eval do
+            add_to_table(["test1", "1" * 1024])
+            add_to_table(["test2", "2" * 500])
           end
-        end
 
-        it "should clear table if entry exceeds table size" do
-          cc = EncodingContext.new(:request, 2048)
+          original_table = cc.table.dup
+          original_size = original_table.join.bytesize +
+            original_table.size * 32
 
-          h = { name: "x-custom", value: "a", index: 0, type: :incremental }
-          e = { name: "large", value: "a" * 2048, index: 0}
+          cc.process({
+                       name: "x-custom",
+                       value: "a" * (2048 - original_size),
+                       type: :incremental
+                     })
 
-          cc.process(h)
-          cc.process(e.merge({type: :substitution}))
-          cc.table.should be_empty
-
-          cc.process(h)
-          cc.process(e.merge({type: :incremental}))
-          cc.table.should be_empty
+          cc.table.first[0].should eq "x-custom"
+          cc.table.size.should eq original_table.size # number of entries
         end
       end
-    end
 
-    context "integration" do
-      before (:all) { @cc = EncodingContext.new(:request) }
-
-      it "should match first header set in spec appendix" do
-        req_headers = [
-          {name: 3, value: "/my-example/index.html"},
-          {name: 11, value: "my-user-agent"},
-          {name: "mynewheader", value: "first"}
-        ]
+      it "should clear table if entry exceeds table size" do
+        cc = EncodingContext.new(table_size: 2048)
+        cc.instance_eval do
+          add_to_table(["test1", "1" * 1024])
+          add_to_table(["test2", "2" * 500])
+        end
 
-        req_headers.each {|h| @cc.process(h.merge({type: :incremental})) }
+        h = { name: "x-custom", value: "a", index: 0, type: :incremental }
+        e = { name: "large", value: "a" * 2048, index: 0}
 
-        @cc.table[30].should eq [":path", "/my-example/index.html"]
-        @cc.table[31].should eq ["user-agent", "my-user-agent"]
-        @cc.table[32].should eq req_headers[2].values
+        cc.process(h)
+        cc.process(e.merge({type: :incremental}))
+        cc.table.should be_empty
       end
 
-      it "should match second header set in spec appendix" do
-        @cc.process({name: 30, type: :indexed})
-        @cc.process({name: 31, type: :indexed})
-        @cc.process({
-          name: 3, value: "/my-example/resources/script.js",
-          index: 30, type: :substitution
-        })
-        @cc.process({name: 32, value: "second", type: :incremental})
-
-        @cc.table[30].should eq [":path", "/my-example/resources/script.js"]
-        @cc.table[31].should eq ["user-agent", "my-user-agent"]
-        @cc.table[32].should eq ["mynewheader", "first"]
-        @cc.table[33].should eq ["mynewheader", "second"]
+      it "should shrink table if set smaller size" do
+        cc = EncodingContext.new(table_size: 2048)
+        cc.instance_eval do
+          add_to_table(["test1", "1" * 1024])
+          add_to_table(["test2", "2" * 500])
+        end
+
+        cc.process({type: :changetablesize, value: 1500})
+        cc.table.size.should be 1
+        cc.table.first[0].should eq 'test2'
       end
     end
   end
 
-  context "encode and decode" do
-    # http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-01#appendix-B
-
-    before (:all) do
-     @cc = Compressor.new(:request)
-     @dc = Decompressor.new(:request)
-    end
-
-    E1_BYTES = [
-      0x44, # (literal header with incremental indexing, name index = 3)
-      0x16, # (header value string length = 22)
-      "/my-example/index.html".bytes,
-      0x4C, # (literal header with incremental indexing, name index = 11)
-      0x0D, # (header value string length = 13)
-      "my-user-agent".bytes,
-      0x40, # (literal header with incremental indexing, new name)
-      0x0B, # (header name string length = 11)
-      "mynewheader".bytes,
-      0x05, # (header value string length = 5)
-      "first".bytes
-    ].flatten
-
-    E1_HEADERS = [
-      [":path", "/my-example/index.html"],
-      ["user-agent", "my-user-agent"],
-      ["mynewheader", "first"]
-    ]
-
-    it "should match first header set in spec appendix" do
-      @cc.encode(E1_HEADERS).bytes.should eq E1_BYTES
-    end
-
-    it "should decode first header set in spec appendix" do
-      @dc.decode(Buffer.new(E1_BYTES.pack("C*"))).should eq E1_HEADERS
-    end
-
-    E2_BYTES = [
-      0x9e, # (indexed header, index = 30: removal from reference set)
-      0xa0, # (indexed header, index = 32: removal from reference set)
-      0x04, # (literal header, substitution indexing, name index = 3)
-      0x1e, # (replaced entry index = 30)
-      0x1f, # (header value string length = 31)
-      "/my-example/resources/script.js".bytes,
-      0x5f,
-      0x02, # (literal header, incremental indexing, name index = 32)
-      0x06, # (header value string length = 6)
-      "second".bytes
-    ].flatten
-
-    E2_HEADERS = [
-      [":path", "/my-example/resources/script.js"],
-      ["user-agent", "my-user-agent"],
-      ["mynewheader", "second"]
-    ]
-
-    it "should match second header set in spec appendix" do
-      # Force incremental indexing, the spec doesn't specify any strategy
-      # for deciding when to use incremental vs substitution indexing, and
-      # early implementations defer to incremental by default:
-      # - https://github.com/sludin/http2-perl/blob/master/lib/HTTP2/Draft/Compress.pm#L157
-      # - https://github.com/MSOpenTech/http2-katana/blob/master/Shared/SharedProtocol/Compression/HeadersDeltaCompression/CompressionProcessor.cs#L259
-      # - https://hg.mozilla.org/try/file/9d9a29992e4d/netwerk/protocol/http/Http2CompressionDraft00.cpp#l636
-      #
-      e2bytes = E2_BYTES.dup
-      e2bytes[2] = 0x44     # incremental indexing, name index = 3
-      e2bytes.delete_at(3)  # remove replacement index byte
-
-      @cc.encode(E2_HEADERS).bytes.should eq e2bytes
-    end
-
-    it "should decode second header set in spec appendix" do
-      @dc.decode(Buffer.new(E2_BYTES.pack("C*"))).should match_array E2_HEADERS
-    end
-
-    it "encode-decode should be invariant" do
-      cc = Compressor.new(:request)
-      dc = Decompressor.new(:request)
-
-      E1_HEADERS.should match_array dc.decode(cc.encode(E1_HEADERS))
-      E2_HEADERS.should match_array dc.decode(cc.encode(E2_HEADERS))
-    end
-
-    it "should encode-decode request set of headers" do
-      cc = Compressor.new(:request)
-      dc = Decompressor.new(:request)
-
-      req = [
-        [":method", "get"],
-        [":host", "localhost"],
-        [":path", "/resource"],
-        ["accept", "*/*"]
-      ]
-
-      dc.decode(cc.encode(req)).should eq req
+  spec_examples = [
+    { title: "D.3. Request Examples without Huffman",
+      type: :request,
+      table_size: 4096,
+      huffman: :never,
+      streams: [
+        { wire: "8286 8441 0f77 7777 2e65 7861 6d70 6c65
+                 2e63 6f6d",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "http"],
+            [":path", "/"],
+            [":authority", "www.example.com"],
+          ],
+          table: [
+            [":authority", "www.example.com"],
+          ],
+          table_size: 57,
+        },
+        { wire: "8286 84be 5808 6e6f 2d63 6163 6865",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "http"],
+            [":path", "/"],
+            [":authority", "www.example.com"],
+            ["cache-control", "no-cache"],
+          ],
+          table: [
+            ["cache-control", "no-cache"],
+            [":authority", "www.example.com"],
+          ],
+          table_size: 110,
+        },
+        { wire: "8287 85bf 400a 6375 7374 6f6d 2d6b 6579
+                 0c63 7573 746f 6d2d 7661 6c75 65",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "https"],
+            [":path", "/index.html"],
+            [":authority", "www.example.com"],
+            ["custom-key", "custom-value"],
+          ],
+          table: [
+            ["custom-key", "custom-value"],
+            ["cache-control", "no-cache"],
+            [":authority", "www.example.com"],
+          ],
+          table_size: 164,
+        }
+      ],
+    },
+    { title: "D.4.  Request Examples with Huffman",
+      type: :request,
+      table_size: 4096,
+      huffman: :always,
+      streams: [
+        { wire: "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "http"],
+            [":path", "/"],
+            [":authority", "www.example.com"],
+          ],
+          table: [
+            [":authority", "www.example.com"],
+          ],
+          table_size: 57,
+        },
+        { wire: "8286 84be 5886 a8eb 1064 9cbf",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "http"],
+            [":path", "/"],
+            [":authority", "www.example.com"],
+            ["cache-control", "no-cache"],
+          ],
+          table: [
+            ["cache-control", "no-cache"],
+            [":authority", "www.example.com"],
+          ],
+          table_size: 110,
+        },
+        { wire: "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925
+                 a849 e95b b8e8 b4bf",
+          emitted: [
+            [":method", "GET"],
+            [":scheme", "https"],
+            [":path", "/index.html"],
+            [":authority", "www.example.com"],
+            ["custom-key", "custom-value"],
+          ],
+          table: [
+            ["custom-key", "custom-value"],
+            ["cache-control", "no-cache"],
+            [":authority", "www.example.com"],
+          ],
+          table_size: 164,
+        },
+      ],
+    },
+    { title: "D.5.  Response Examples without Huffman",
+      type: :response,
+      table_size: 256,
+      huffman: :never,
+      streams: [
+        { wire: "4803 3330 3258 0770 7269 7661 7465 611d
+                 4d6f 6e2c 2032 3120 4f63 7420 3230 3133
+                 2032 303a 3133 3a32 3120 474d 546e 1768
+                 7474 7073 3a2f 2f77 7777 2e65 7861 6d70
+                 6c65 2e63 6f6d",
+          emitted: [
+            [":status", "302"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["location", "https://www.example.com"],
+          ],
+          table: [
+            ["location", "https://www.example.com"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["cache-control", "private"],
+            [":status", "302"],
+          ],
+          table_size: 222,
+        },
+        { wire: "4803 3330 37c1 c0bf",
+          emitted: [
+            [":status", "307"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["location", "https://www.example.com"],
+          ],
+          table: [
+            [":status", "307"],
+            ["location", "https://www.example.com"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["cache-control", "private"],
+          ],
+          table_size: 222,
+        },
+        { wire: "88c1 611d 4d6f 6e2c 2032 3120 4f63 7420
+                 3230 3133 2032 303a 3133 3a32 3220 474d
+                 54c0 5a04 677a 6970 7738 666f 6f3d 4153
+                 444a 4b48 514b 425a 584f 5157 454f 5049
+                 5541 5851 5745 4f49 553b 206d 6178 2d61
+                 6765 3d33 3630 303b 2076 6572 7369 6f6e
+                 3d31",
+          emitted: [
+            [":status", "200"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:22 GMT"],
+            ["location", "https://www.example.com"],
+            ["content-encoding", "gzip"],
+            ["set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"],
+          ],
+          table: [
+            ["set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"],
+            ["content-encoding", "gzip"],
+            ["date", "Mon, 21 Oct 2013 20:13:22 GMT"],
+          ],
+          table_size: 215,
+        },
+      ],
+    },
+    { title: "D.6.  Response Examples with Huffman",
+      type: :response,
+      table_size: 256,
+      huffman: :always,
+      streams: [
+        { wire: "4882 6402 5885 aec3 771a 4b61 96d0 7abe
+                 9410 54d4 44a8 2005 9504 0b81 66e0 82a6
+                 2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8
+                 e9ae 82ae 43d3",
+          emitted: [
+            [":status", "302"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["location", "https://www.example.com"],
+          ],
+          table: [
+            ["location", "https://www.example.com"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["cache-control", "private"],
+            [":status", "302"],
+          ],
+          table_size: 222,
+        },
+        { wire: "4883 640e ffc1 c0bf",
+          emitted: [
+            [":status", "307"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["location", "https://www.example.com"],
+          ],
+          table: [
+            [":status", "307"],
+            ["location", "https://www.example.com"],
+            ["date", "Mon, 21 Oct 2013 20:13:21 GMT"],
+            ["cache-control", "private"],
+          ],
+          table_size: 222,
+        },
+        { wire: "88c1 6196 d07a be94 1054 d444 a820 0595
+                 040b 8166 e084 a62d 1bff c05a 839b d9ab
+                 77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b
+                 3960 d5af 2708 7f36 72c1 ab27 0fb5 291f
+                 9587 3160 65c0 03ed 4ee5 b106 3d50 07",
+          emitted: [
+            [":status", "200"],
+            ["cache-control", "private"],
+            ["date", "Mon, 21 Oct 2013 20:13:22 GMT"],
+            ["location", "https://www.example.com"],
+            ["content-encoding", "gzip"],
+            ["set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"],
+          ],
+          table: [
+            ["set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"],
+            ["content-encoding", "gzip"],
+            ["date", "Mon, 21 Oct 2013 20:13:22 GMT"],
+          ],
+          table_size: 215,
+        },
+      ],
+    },
+  ]
+
+  context "decode" do
+    spec_examples.each do |ex|
+      context "spec example #{ex[:title]}" do
+        ex[:streams].size.times do |nth|
+          context "request #{nth+1}" do
+            before { @dc = Decompressor.new(table_size: ex[:table_size]) }
+            before do
+              (0...nth).each do |i|
+                bytes = [ex[:streams][i][:wire].delete(" \n")].pack("H*")
+                @dc.decode(HTTP2::Buffer.new(bytes))
+              end
+            end
+            subject do
+              bytes = [ex[:streams][nth][:wire].delete(" \n")].pack("H*")
+              @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
+            end
+            it "should emit expected headers" do
+              subject
+              # order-perserving compare
+              @emitted.should eq ex[:streams][nth][:emitted]
+            end
+            it "should update header table" do
+              subject
+              @dc.instance_eval{@cc.table}.should eq ex[:streams][nth][:table]
+            end
+            it "should compute header table size" do
+              subject
+              @dc.instance_eval{@cc.current_table_size}.should eq ex[:streams][nth][:table_size]
+            end
+          end
+        end
+      end
     end
+  end
 
-    it "should downcase all request header names" do
-      cc = Compressor.new(:request)
-      dc = Decompressor.new(:request)
-
-      req = [["Accept", "IMAGE/PNG"]]
-      recv = dc.decode(cc.encode(req))
-      recv.should eq [["accept", "IMAGE/PNG"]]
+  context "encode" do
+    spec_examples.each do |ex|
+      context "spec example #{ex[:title]}" do
+        ex[:streams].size.times do |nth|
+          context "request #{nth+1}" do
+            before { @cc = Compressor.new(table_size: ex[:table_size],
+                                          huffman: ex[:huffman]) }
+            before do
+              (0...nth).each do |i|
+                @cc.encode(ex[:streams][i][:emitted])
+              end
+            end
+            subject do
+              @cc.encode(ex[:streams][nth][:emitted])
+            end
+            it "should emit expected bytes on wire" do
+              subject.unpack("H*").first.should eq ex[:streams][nth][:wire].delete(" \n")
+            end
+            it "should update header table" do
+              subject
+              @cc.instance_eval{@cc.table}.should eq ex[:streams][nth][:table]
+            end
+            it "should compute header table size" do
+              subject
+              @cc.instance_eval{@cc.current_table_size}.should eq ex[:streams][nth][:table_size]
+            end
+          end
+        end
+      end
     end
   end
+
 end