http-2 0.7.0 → 0.8.0

data/lib/http/2/version.rb

@@ -1,3 +1,3 @@
 module HTTP2
-  VERSION = "0.7.0"
+  VERSION = '0.8.0'.freeze
 end

data/lib/tasks/generate_huffman_table.rb

@@ -1,4 +1,4 @@
-desc "Generate Huffman precompiled table in huffman_statemachine.rb"
+desc 'Generate Huffman precompiled table in huffman_statemachine.rb'
 task :generate_table do
   HuffmanTable::Node.generate_state_table
 end
@@ -14,16 +14,17 @@ module HuffmanTable
     attr_accessor :next, :emit, :final, :depth
     attr_accessor :transitions
     attr_accessor :id
-    @@id = 0
+    @@id = 0 # rubocop:disable Style/ClassVars
     def initialize(depth)
       @next = [nil, nil]
       @id = @@id
-      @@id += 1
+      @@id += 1 # rubocop:disable Style/ClassVars
       @final = false
       @depth = depth
     end
+
     def add(code, len, chr)
-      chr == EOS && @depth <= 7 and self.final = true
+      self.final = true if chr == EOS && @depth <= 7
       if len == 0
         @emit = chr
       else
@@ -69,14 +70,13 @@ module HuffmanTable
           (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
+            next unless n.emit
+            if n.emit == EOS
+              emit = EOS # cause error on decoding
+            else
+              emit << n.emit.chr(Encoding::BINARY) unless emit == EOS
             end
+            n = @root
           end
           node.transitions[input] = Transition.new(emit, n)
           togo << n
@@ -95,14 +95,14 @@ module HuffmanTable
       id_state[0] = @root
       max_final = 0
       id = 1
-      (@states - [@root]).sort_by{|s|s.final ? 0 : 1}.each do |s|
+      (@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|
+      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.
@@ -119,16 +119,22 @@ module HTTP2
 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 '        ['
+          string = (1 << BITS_AT_ONCE).times.map do |t|
+            transition = n.transitions.fetch(t)
+            emit = transition.emit
+            unless emit == EOS
+              bytes = emit.bytes
+              fail ArgumentError if bytes.size > 1
+              emit = bytes.first
+            end
+            "[#{emit.inspect}, #{state_id.fetch(transition.node)}]"
+          end.join(', ')
+          f.print(string)
           f.print "],\n"
         end
         f.print <<TAILER
-      ]
+      ].each { |arr| arr.each { |subarr| subarr.each(&:freeze) }.freeze }.freeze
     end
   end
 end
@@ -136,22 +142,22 @@ TAILER
       end
     end
 
-    def self.root
-      @root
+    class << self
+      attr_reader :root
     end
 
     # Test decoder
     def self.decode(input)
       emit = ''
       n = root
-      nibbles = input.unpack("C*").flat_map{|b| [((b & 0xf0) >> 4), b & 0xf]}
+      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}
+      unless n.final && nibbles.all? { |x| x == 0xf }
         puts "len = #{emit.size} n.final = #{n.final} nibbles = #{nibbles}"
       end
       emit

data/spec/buffer_spec.rb

@@ -1,23 +1,21 @@
-require "helper"
+require 'helper'
 
-describe HTTP2::Buffer do
+RSpec.describe HTTP2::Buffer do
+  let(:b) { Buffer.new('émalgré') }
 
-  let(:b) { Buffer.new("émalgré") }
-
-  it "should force 8-bit encoding" do
-    b.encoding.to_s.should eq "ASCII-8BIT"
+  it 'should force 8-bit encoding' do
+    expect(b.encoding.to_s).to eq 'ASCII-8BIT'
   end
 
-  it "should return bytesize of the buffer" do
-    b.size.should eq 9
+  it 'should return bytesize of the buffer' do
+    expect(b.size).to eq 9
   end
 
-  it "should read single byte at a time" do
-    9.times { b.read(1).should_not be_nil }
+  it 'should read single byte at a time' do
+    9.times { expect(b.read(1)).not_to be_nil }
   end
 
-  it "should unpack an unsigned 32-bit int" do
-    Buffer.new([256].pack("N")).read_uint32.should eq 256
+  it 'should unpack an unsigned 32-bit int' do
+    expect(Buffer.new([256].pack('N')).read_uint32).to eq 256
   end
-
 end

data/spec/client_spec.rb

@@ -1,93 +1,92 @@
-require "helper"
+require 'helper'
 
-describe HTTP2::Client do
+RSpec.describe HTTP2::Client do
   before(:each) do
     @client = Client.new
   end
 
   let(:f) { Framer.new }
 
-  context "initialization and settings" do
-    it "should return odd stream IDs" do
-      @client.new_stream.id.should_not be_even
+  context 'initialization and settings' do
+    it 'should return odd stream IDs' do
+      expect(@client.new_stream.id).not_to be_even
     end
 
-    it "should emit connection header and SETTINGS on new client connection" do
+    it 'should emit connection header and SETTINGS on new client connection' do
       frames = []
       @client.on(:frame) { |bytes| frames << bytes }
-      @client.ping("12345678")
+      @client.ping('12345678')
 
-      frames[0].should eq CONNECTION_PREFACE_MAGIC
-      f.parse(frames[1])[:type].should eq :settings
+      expect(frames[0]).to eq CONNECTION_PREFACE_MAGIC
+      expect(f.parse(frames[1])[:type]).to eq :settings
     end
 
-    it "should initialize client with custom connection settings" do
+    it 'should initialize client with custom connection settings' do
       frames = []
 
-      @client = Client.new(:settings_max_concurrent_streams => 200)
+      @client = Client.new(settings_max_concurrent_streams: 200)
       @client.on(:frame) { |bytes| frames << bytes }
-      @client.ping("12345678")
+      @client.ping('12345678')
 
       frame = f.parse(frames[1])
-      frame[:type].should eq :settings
-      frame[:payload].should include([:settings_max_concurrent_streams, 200])
+      expect(frame[:type]).to eq :settings
+      expect(frame[:payload]).to include([:settings_max_concurrent_streams, 200])
     end
   end
 
-  context "push" do
-    it "should disallow client initiated push" do
+  context 'push' do
+    it 'should disallow client initiated push' do
       expect do
         @client.promise({}) {}
-      end.to raise_error(Exception)
+      end.to raise_error(NoMethodError)
     end
 
-    it "should raise error on PUSH_PROMISE against stream 0" do
-      expect {
-        @client << set_stream_id(f.generate(PUSH_PROMISE), 0)
-      }.to raise_error(ProtocolError)
+    it 'should raise error on PUSH_PROMISE against stream 0' do
+      expect do
+        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 0)
+      end.to raise_error(ProtocolError)
     end
 
-    it "should raise error on PUSH_PROMISE against bogus stream" do
-      expect {
-        @client << set_stream_id(f.generate(PUSH_PROMISE), 31415)
-      }.to raise_error(ProtocolError)
+    it 'should raise error on PUSH_PROMISE against bogus stream' do
+      expect do
+        @client << set_stream_id(f.generate(PUSH_PROMISE.dup), 31_415)
+      end.to raise_error(ProtocolError)
     end
 
-    it "should raise error on PUSH_PROMISE against non-idle stream" do
-      expect {
+    it 'should raise error on PUSH_PROMISE against non-idle stream' do
+      expect do
         s = @client.new_stream
         s.send HEADERS
 
         @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
         @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
-     }.to raise_error(ProtocolError)
+      end.to raise_error(ProtocolError)
     end
 
-    it "should emit stream object for received PUSH_PROMISE" do
+    it 'should emit stream object for received PUSH_PROMISE' do
       s = @client.new_stream
-      s.send HEADERS
+      s.send HEADERS.deep_dup
 
       promise = nil
-      @client.on(:promise) {|s| promise = s }
-      @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+      @client.on(:promise) { |stream| promise = stream }
+      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
 
-      promise.id.should eq 2
-      promise.state.should eq :reserved_remote
+      expect(promise.id).to eq 2
+      expect(promise.state).to eq :reserved_remote
     end
 
-    it "should auto RST_STREAM promises against locally-RST stream" do
+    it 'should auto RST_STREAM promises against locally-RST stream' do
       s = @client.new_stream
-      s.send HEADERS
+      s.send HEADERS.deep_dup
       s.close
 
-      @client.stub(:send)
-      @client.should_receive(:send) do |frame|
-        frame[:type].should eq :rst_stream
-        frame[:stream].should eq 2
+      allow(@client).to receive(:send)
+      expect(@client).to receive(:send) do |frame|
+        expect(frame[:type]).to eq :rst_stream
+        expect(frame[:stream]).to eq 2
       end
 
-      @client << set_stream_id(f.generate(PUSH_PROMISE), s.id)
+      @client << set_stream_id(f.generate(PUSH_PROMISE.dup), s.id)
     end
   end
-
 end

data/spec/compressor_spec.rb

@@ -1,246 +1,246 @@
-require "helper"
-
-describe HTTP2::Header do
+require 'helper'
 
+RSpec.describe HTTP2::Header do
   let(:c) { Compressor.new }
   let(:d) { Decompressor.new }
 
-  context "literal representation" do
-    context "integer" do
-      it "should encode 10 using a 5-bit prefix" do
+  context 'literal representation' do
+    context 'integer' do
+      it 'should encode 10 using a 5-bit prefix' do
         buf = c.integer(10, 5)
-        buf.should eq [10].pack('C')
-        d.integer(Buffer.new(buf), 5).should eq 10
+        expect(buf).to eq [10].pack('C')
+        expect(d.integer(Buffer.new(buf), 5)).to eq 10
       end
 
-      it "should encode 10 using a 0-bit prefix" do
+      it 'should encode 10 using a 0-bit prefix' do
         buf = c.integer(10, 0)
-        buf.should eq [10].pack('C')
-        d.integer(Buffer.new(buf), 0).should eq 10
+        expect(buf).to eq [10].pack('C')
+        expect(d.integer(Buffer.new(buf), 0)).to eq 10
       end
 
-      it "should encode 1337 using a 5-bit prefix" do
+      it 'should encode 1337 using a 5-bit prefix' do
         buf = c.integer(1337, 5)
-        buf.should eq [31,128+26,10].pack('C*')
-        d.integer(Buffer.new(buf), 5).should eq 1337
+        expect(buf).to eq [31, 128 + 26, 10].pack('C*')
+        expect(d.integer(Buffer.new(buf), 5)).to eq 1337
       end
 
-      it "should encode 1337 using a 0-bit prefix" do
-        buf = c.integer(1337,0)
-        buf.should eq [128+57,10].pack('C*')
-        d.integer(Buffer.new(buf), 0).should eq 1337
+      it 'should encode 1337 using a 0-bit prefix' do
+        buf = c.integer(1337, 0)
+        expect(buf).to eq [128 + 57, 10].pack('C*')
+        expect(d.integer(Buffer.new(buf), 0)).to eq 1337
       end
     end
 
-    context "string" do
-      [ ['with huffman',    :always, 0x80 ],
-        ['without huffman', :never,  0] ].each do |desc, option, msb|
-        let (:trailer) { "trailer" }
+    context 'string' do
+      [
+        ['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],
+          ['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
+            expect(str.getbyte(0) & 0x80).to eq msb
 
             buf = Buffer.new(str + trailer)
-            d.string(buf).should eq plain
-            buf.should eq trailer
+            expect(d.string(buf)).to eq plain
+            expect(buf).to eq trailer
           end
         end
       end
-      context "choosing shorter representation" do
-        [ ['日本語', :plain],
-          ['200', :huffman],
-          ['xq', :plain],   # prefer plain if equal size
+      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)
+            expect(wire.getbyte(0) & 0x80).to eq(choice == :plain ? 0 : 0x80)
           end
         end
       end
     end
   end
 
-  context "header representation" do
-    it "should handle indexed representation" do
-      h = {name: 10, type: :indexed}
+  context 'header representation' do
+    it 'should handle indexed representation' do
+      h = { name: 10, type: :indexed }
       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
+      expect(wire.readbyte(0) & 0x80).to eq 0x80
+      expect(wire.readbyte(0) & 0x7f).to eq h[:name] + 1
+      expect(d.header(wire)).to eq h
     end
-    it "should raise when decoding indexed representation with index zero" do
-      h = {name: 10, type: :indexed}
+    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')
+      wire[0] = 0x80.chr(Encoding::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}
+    context 'literal w/o indexing representation' do
+      it 'should handle indexed header' do
+        h = { name: 10, value: 'my-value', type: :noindex }
         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
+        expect(wire.readbyte(0) & 0xf0).to eq 0x0
+        expect(wire.readbyte(0) & 0x0f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
       end
 
-      it "should handle literal header" do
-        h = {name: "x-custom", value: "my-value", type: :noindex}
+      it 'should handle literal header' do
+        h = { name: 'x-custom', value: 'my-value', type: :noindex }
         wire = c.header(h)
-        (wire.readbyte(0) & 0xf0).should eq 0x0
-        (wire.readbyte(0) & 0x0f).should eq 0
-        d.header(wire).should eq h
+        expect(wire.readbyte(0) & 0xf0).to eq 0x0
+        expect(wire.readbyte(0) & 0x0f).to eq 0
+        expect(d.header(wire)).to eq h
       end
     end
 
-    context "literal w/ incremental indexing" do
-      it "should handle indexed header" do
-        h = {name: 10, value: "my-value", type: :incremental}
+    context 'literal w/ incremental indexing' do
+      it 'should handle indexed header' do
+        h = { name: 10, value: 'my-value', type: :incremental }
         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
+        expect(wire.readbyte(0) & 0xc0).to eq 0x40
+        expect(wire.readbyte(0) & 0x3f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
       end
 
-      it "should handle literal header" do
-        h = {name: "x-custom", value: "my-value", type: :incremental}
+      it 'should handle literal header' do
+        h = { name: 'x-custom', value: 'my-value', type: :incremental }
         wire = c.header(h)
-        (wire.readbyte(0) & 0xc0).should eq 0x40
-        (wire.readbyte(0) & 0x3f).should eq 0
-        d.header(wire).should eq h
+        expect(wire.readbyte(0) & 0xc0).to eq 0x40
+        expect(wire.readbyte(0) & 0x3f).to eq 0
+        expect(d.header(wire)).to eq h
       end
     end
 
-    context "literal never indexed" do
-      it "should handle indexed header" do
-        h = {name: 10, value: "my-value", type: :neverindexed}
+    context 'literal never indexed' do
+      it 'should handle indexed header' do
+        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
+        expect(wire.readbyte(0) & 0xf0).to eq 0x10
+        expect(wire.readbyte(0) & 0x0f).to eq h[:name] + 1
+        expect(d.header(wire)).to eq h
       end
 
-      it "should handle literal header" do
-        h = {name: "x-custom", value: "my-value", type: :neverindexed}
+      it 'should handle literal header' do
+        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
+        expect(wire.readbyte(0) & 0xf0).to eq 0x10
+        expect(wire.readbyte(0) & 0x0f).to eq 0
+        expect(d.header(wire)).to eq h
       end
     end
   end
 
-  context "shared compression context" do
+  context 'shared compression context' do
     before(:each) { @cc = EncodingContext.new }
 
-    it "should be initialized with empty headers" do
+    it 'should be initialized with empty headers' do
       cc = EncodingContext.new
-      cc.table.should be_empty
+      expect(cc.table).to be_empty
     end
 
-    context "processing" do
-      [ ["no indexing", :noindex],
-        ["never indexed", :neverindexed]].each do |desc, type|
+    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
+          it 'should process indexed header with literal value' do
             original_table = @cc.table.dup
 
-            emit = @cc.process({name: 4, value: "/path", type: type})
-            emit.should eq [":path", "/path"]
-            @cc.table.should eq original_table
+            emit = @cc.process(name: 4, value: '/path', type: type)
+            expect(emit).to eq [':path', '/path']
+            expect(@cc.table).to eq original_table
           end
 
-          it "should process literal header with literal value" do
+          it 'should process literal header with literal value' do
             original_table = @cc.table.dup
 
-            emit = @cc.process({name: "x-custom", value: "random", type: type})
-            emit.should eq ["x-custom", "random"]
-            @cc.table.should eq original_table
+            emit = @cc.process(name: 'x-custom', value: 'random', type: type)
+            expect(emit).to eq ['x-custom', 'random']
+            expect(@cc.table).to eq original_table
           end
         end
       end
 
-      context "incremental indexing" do
-        it "should process indexed header with literal value" do
+      context 'incremental indexing' do
+        it 'should process indexed header with literal value' do
           original_table = @cc.table.dup
 
-          emit = @cc.process({name: 4, value: "/path", type: :incremental})
-          emit.should eq [":path", "/path"]
-          (@cc.table - original_table).should eq [[":path", "/path"]]
+          emit = @cc.process(name: 4, value: '/path', type: :incremental)
+          expect(emit).to eq [':path', '/path']
+          expect(@cc.table - original_table).to eq [[':path', '/path']]
         end
 
-        it "should process literal header with literal value" do
+        it 'should process literal header with literal value' do
           original_table = @cc.table.dup
 
-          @cc.process({name: "x-custom", value: "random", type: :incremental})
-          (@cc.table - original_table).should eq [["x-custom", "random"]]
+          @cc.process(name: 'x-custom', value: 'random', type: :incremental)
+          expect(@cc.table - original_table).to eq [['x-custom', 'random']]
         end
       end
 
-      context "size bounds" do
-        it "should drop headers from end of table" do
+      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])
+            add_to_table(['test1', '1' * 1024])
+            add_to_table(['test2', '2' * 500])
           end
 
           original_table = cc.table.dup
-          original_size = original_table.join.bytesize +
-            original_table.size * 32
+          original_size = original_table.join.bytesize + original_table.size * 32
 
-          cc.process({
-                       name: "x-custom",
-                       value: "a" * (2048 - original_size),
-                       type: :incremental
-                     })
+          cc.process(name: 'x-custom',
+                     value: 'a' * (2048 - original_size),
+                     type: :incremental)
 
-          cc.table.first[0].should eq "x-custom"
-          cc.table.size.should eq original_table.size # number of entries
+          expect(cc.table.first[0]).to eq 'x-custom'
+          expect(cc.table.size).to eq original_table.size # number of entries
         end
       end
 
-      it "should clear table if entry exceeds table size" do
+      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])
+          add_to_table(['test1', '1' * 1024])
+          add_to_table(['test2', '2' * 500])
         end
 
-        h = { name: "x-custom", value: "a", index: 0, type: :incremental }
-        e = { name: "large", value: "a" * 2048, index: 0}
+        h = { name: 'x-custom', value: 'a', index: 0, type: :incremental }
+        e = { name: 'large', value: 'a' * 2048, index: 0 }
 
         cc.process(h)
-        cc.process(e.merge({type: :incremental}))
-        cc.table.should be_empty
+        cc.process(e.merge(type: :incremental))
+        expect(cc.table).to be_empty
       end
 
-      it "should shrink table if set smaller size" do
+      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])
+          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'
+        cc.process(type: :changetablesize, value: 1500)
+        expect(cc.table.size).to be 1
+        expect(cc.table.first[0]).to eq 'test2'
       end
     end
   end
 
   spec_examples = [
-    { title: "D.3. Request Examples without Huffman",
+    { title: 'D.3. Request Examples without Huffman',
       type: :request,
       table_size: 4096,
       huffman: :never,
@@ -248,98 +248,98 @@ describe HTTP2::Header do
         { wire: "8286 8441 0f77 7777 2e65 7861 6d70 6c65
                  2e63 6f6d",
           emitted: [
-            [":method", "GET"],
-            [":scheme", "http"],
-            [":path", "/"],
-            [":authority", "www.example.com"],
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
           ],
           table: [
-            [":authority", "www.example.com"],
+            [':authority', 'www.example.com'],
           ],
           table_size: 57,
         },
-        { wire: "8286 84be 5808 6e6f 2d63 6163 6865",
+        { wire: '8286 84be 5808 6e6f 2d63 6163 6865',
           emitted: [
-            [":method", "GET"],
-            [":scheme", "http"],
-            [":path", "/"],
-            [":authority", "www.example.com"],
-            ["cache-control", "no-cache"],
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+            ['cache-control', 'no-cache'],
           ],
           table: [
-            ["cache-control", "no-cache"],
-            [":authority", "www.example.com"],
+            ['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"],
+            [':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"],
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
           ],
           table_size: 164,
-        }
+        },
       ],
     },
-    { title: "D.4.  Request Examples with Huffman",
+    { 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",
+        { wire: '8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff',
           emitted: [
-            [":method", "GET"],
-            [":scheme", "http"],
-            [":path", "/"],
-            [":authority", "www.example.com"],
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
           ],
           table: [
-            [":authority", "www.example.com"],
+            [':authority', 'www.example.com'],
           ],
           table_size: 57,
         },
-        { wire: "8286 84be 5886 a8eb 1064 9cbf",
+        { wire: '8286 84be 5886 a8eb 1064 9cbf',
           emitted: [
-            [":method", "GET"],
-            [":scheme", "http"],
-            [":path", "/"],
-            [":authority", "www.example.com"],
-            ["cache-control", "no-cache"],
+            [':method', 'GET'],
+            [':scheme', 'http'],
+            [':path', '/'],
+            [':authority', 'www.example.com'],
+            ['cache-control', 'no-cache'],
           ],
           table: [
-            ["cache-control", "no-cache"],
-            [":authority", "www.example.com"],
+            ['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"],
+            [':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"],
+            ['custom-key', 'custom-value'],
+            ['cache-control', 'no-cache'],
+            [':authority', 'www.example.com'],
           ],
           table_size: 164,
         },
       ],
     },
-    { title: "D.5.  Response Examples without Huffman",
+    { title: 'D.5.  Response Examples without Huffman',
       type: :response,
       table_size: 256,
       huffman: :never,
@@ -350,31 +350,31 @@ describe HTTP2::Header do
                  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"],
+            [':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"],
+            ['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",
+        { 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"],
+            [':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"],
+            [':status', '307'],
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
           ],
           table_size: 222,
         },
@@ -386,23 +386,23 @@ describe HTTP2::Header do
                  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"],
+            [':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"],
+            ['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",
+    { title: 'D.6.  Response Examples with Huffman',
       type: :response,
       table_size: 256,
       huffman: :always,
@@ -412,31 +412,31 @@ describe HTTP2::Header do
                  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"],
+            [':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"],
+            ['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",
+        { 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"],
+            [':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"],
+            [':status', '307'],
+            ['location', 'https://www.example.com'],
+            ['date', 'Mon, 21 Oct 2013 20:13:21 GMT'],
+            ['cache-control', 'private'],
           ],
           table_size: 222,
         },
@@ -446,17 +446,17 @@ describe HTTP2::Header do
                  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"],
+            [':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"],
+            ['set-cookie', 'foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1'],
+            ['content-encoding', 'gzip'],
+            ['date', 'Mon, 21 Oct 2013 20:13:22 GMT'],
           ],
           table_size: 215,
         },
@@ -464,34 +464,34 @@ describe HTTP2::Header do
     },
   ]
 
-  context "decode" do
+  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
+          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*")
+                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*")
+              bytes = [ex[:streams][nth][:wire].delete(" \n")].pack('H*')
               @emitted = @dc.decode(HTTP2::Buffer.new(bytes))
             end
-            it "should emit expected headers" do
+            it 'should emit expected headers' do
               subject
               # order-perserving compare
-              @emitted.should eq ex[:streams][nth][:emitted]
+              expect(@emitted).to eq ex[:streams][nth][:emitted]
             end
-            it "should update header table" do
+            it 'should update header table' do
               subject
-              @dc.instance_eval{@cc.table}.should eq ex[:streams][nth][:table]
+              expect(@dc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
             end
-            it "should compute header table size" do
+            it 'should compute header table size' do
               subject
-              @dc.instance_eval{@cc.current_table_size}.should eq ex[:streams][nth][:table_size]
+              expect(@dc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
             end
           end
         end
@@ -499,13 +499,15 @@ describe HTTP2::Header do
     end
   end
 
-  context "encode" do
+  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]) }
+          context "request #{nth + 1}" do
+            before do
+              @cc = Compressor.new(table_size: ex[:table_size],
+                                   huffman: ex[:huffman])
+            end
             before do
               (0...nth).each do |i|
                 @cc.encode(ex[:streams][i][:emitted])
@@ -514,21 +516,20 @@ describe HTTP2::Header do
             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")
+            it 'should emit expected bytes on wire' do
+              expect(subject.unpack('H*').first).to eq ex[:streams][nth][:wire].delete(" \n")
             end
-            it "should update header table" do
+            it 'should update header table' do
               subject
-              @cc.instance_eval{@cc.table}.should eq ex[:streams][nth][:table]
+              expect(@cc.instance_eval { @cc.table }).to eq ex[:streams][nth][:table]
             end
-            it "should compute header table size" do
+            it 'should compute header table size' do
               subject
-              @cc.instance_eval{@cc.current_table_size}.should eq ex[:streams][nth][:table_size]
+              expect(@cc.instance_eval { @cc.current_table_size }).to eq ex[:streams][nth][:table_size]
             end
           end
         end
       end
     end
   end
-
 end