http-2 0.7.0 → 0.8.0

data/example/upgrade_server.rb

@@ -0,0 +1,191 @@
+require_relative 'helper'
+require 'http_parser'
+require 'base64'
+
+options = { port: 8080 }
+OptionParser.new do |opts|
+  opts.banner = 'Usage: server.rb [options]'
+
+  opts.on('-s', '--secure', 'HTTPS mode') do |v|
+    options[:secure] = v
+  end
+
+  opts.on('-p', '--port [Integer]', 'listen port') do |v|
+    options[:port] = v
+  end
+end.parse!
+
+puts "Starting server on port #{options[:port]}"
+server = TCPServer.new(options[:port])
+
+if options[:secure]
+  ctx = OpenSSL::SSL::SSLContext.new
+  ctx.cert = OpenSSL::X509::Certificate.new(File.open('keys/mycert.pem'))
+  ctx.key = OpenSSL::PKey::RSA.new(File.open('keys/mykey.pem'))
+  ctx.npn_protocols = [DRAFT]
+
+  server = OpenSSL::SSL::SSLServer.new(server, ctx)
+end
+
+class UpgradeHandler
+
+  VALID_UPGRADE_METHODS = %w[GET OPTIONS]
+  UPGRADE_RESPONSE = ("HTTP/1.1 101 Switching Protocols\n" +
+                      "Connection: Upgrade\n" +
+                      "Upgrade: h2c\n\n").freeze
+
+  attr_reader :complete, :headers, :body, :parsing
+
+  def initialize conn, sock
+    @conn, @sock = conn, sock
+    @complete, @parsing = false, false
+    @body = ''
+    @parser = ::HTTP::Parser.new(self)
+  end
+
+  def <<(data)
+    @parsing ||= true
+    @parser << data
+    if complete
+
+      @sock.write UPGRADE_RESPONSE
+
+      settings = headers['http2-settings']
+      request = {
+        ':scheme'    => 'http',
+        ':method'    => @parser.http_method,
+        ':authority' => headers['Host'],
+        ':path'      => @parser.request_url
+      }.merge(headers)
+
+      @conn.upgrade(settings, request, @body)
+    end
+  end
+
+  def complete!; @complete = true; end
+
+  def on_headers_complete(headers)
+    @headers = headers
+  end
+
+  def on_body(chunk)
+    @body << chunk
+  end
+
+  def on_message_complete
+    raise unless VALID_UPGRADE_METHODS.include?(@parser.http_method)
+    @parsing = false
+    complete!
+  end
+
+end
+
+loop do
+  sock = server.accept
+  puts 'New TCP connection!'
+
+  conn = HTTP2::Server.new
+  conn.on(:frame) do |bytes|
+    # puts "Writing bytes: #{bytes.unpack("H*").first}"
+    sock.write bytes
+  end
+  conn.on(:frame_sent) do |frame|
+    puts "Sent frame: #{frame.inspect}"
+  end
+  conn.on(:frame_received) do |frame|
+    puts "Received frame: #{frame.inspect}"
+  end
+
+  conn.on(:stream) do |stream|
+    log = Logger.new(stream.id)
+    req, buffer = {}, ''
+
+    stream.on(:active) { log.info 'client opened new stream' }
+    stream.on(:close) do
+      log.info 'stream closed'
+    end
+
+    stream.on(:headers) do |h|
+      req = Hash[*h.flatten]
+      log.info "request headers: #{h}"
+    end
+
+    stream.on(:data) do |d|
+      log.info "payload chunk: <<#{d}>>"
+      buffer << d
+    end
+
+    stream.on(:half_close) do
+      log.info 'client closed its end of the stream'
+
+      if req['Upgrade']
+        log.info "Processing h2c Upgrade request: #{req}"
+
+        # Don't respond to OPTIONS...
+        if req[':method'] != "OPTIONS"
+          response = 'Hello h2c world!'
+          stream.headers({
+            ':status' => '200',
+            'content-length' => response.bytesize.to_s,
+            'content-type' => 'text/plain',
+          }, end_stream: false)
+          stream.data(response)
+        end
+      else
+
+        response = nil
+        if req[':method'] == 'POST'
+          log.info "Received POST request, payload: #{buffer}"
+          response = "Hello HTTP 2.0! POST payload: #{buffer}"
+        else
+          log.info 'Received GET request'
+          response = 'Hello HTTP 2.0! GET request'
+        end
+
+        stream.headers({
+          ':status' => '200',
+          'content-length' => response.bytesize.to_s,
+          'content-type' => 'text/plain',
+        }, end_stream: false)
+
+        # split response into multiple DATA frames
+        stream.data(response.slice!(0, 5), end_stream: false)
+        stream.data(response)
+      end
+    end
+  end
+
+  uh = UpgradeHandler.new(conn, sock)
+
+  while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
+    data = sock.readpartial(1024)
+    # puts "Received bytes: #{data.unpack("H*").first}"
+
+    begin
+      case
+      when !uh.parsing && !uh.complete
+
+        if data.start_with?(*UpgradeHandler::VALID_UPGRADE_METHODS)
+          uh << data
+        else
+          uh.complete!
+          conn << data
+        end
+
+      when uh.parsing && !uh.complete
+        uh << data
+
+      when uh.complete
+        conn << data
+      end
+
+    rescue => e
+      puts "Exception: #{e}, #{e.message} - closing socket."
+      puts e.backtrace.last(10).join("\n")
+      sock.close
+    end
+  end
+end
+
+# echo foo=bar | nghttp -d - -t 0 -vu http://127.0.0.1:8080/
+# nghttp -vu http://127.0.0.1:8080/

data/http-2.gemspec

@@ -4,19 +4,20 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'http/2/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "http-2"
+  spec.name          = 'http-2'
   spec.version       = HTTP2::VERSION
-  spec.authors       = ["Ilya Grigorik", "Kaoru Maeda"]
-  spec.email         = ["ilya@igvita.com"]
-  spec.description   = "Pure-ruby HTTP 2.0 protocol implementation"
+  spec.authors       = ['Ilya Grigorik', 'Kaoru Maeda']
+  spec.email         = ['ilya@igvita.com']
+  spec.description   = 'Pure-ruby HTTP 2.0 protocol implementation'
   spec.summary       = spec.description
-  spec.homepage      = "https://github.com/igrigorik/http-2"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/igrigorik/http-2'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>=2.0.0'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency 'bundler', '~> 1.3'
 end

data/lib/http/2.rb

@@ -1,13 +1,13 @@
-require "http/2/version"
-require "http/2/error"
-require "http/2/emitter"
-require "http/2/buffer"
-require "http/2/flow_buffer"
-require "http/2/huffman"
-require "http/2/huffman_statemachine"
-require "http/2/compressor"
-require "http/2/framer"
-require "http/2/connection"
-require "http/2/client"
-require "http/2/server"
-require "http/2/stream"
+require 'http/2/version'
+require 'http/2/error'
+require 'http/2/emitter'
+require 'http/2/buffer'
+require 'http/2/flow_buffer'
+require 'http/2/huffman'
+require 'http/2/huffman_statemachine'
+require 'http/2/compressor'
+require 'http/2/framer'
+require 'http/2/connection'
+require 'http/2/client'
+require 'http/2/server'
+require 'http/2/stream'

data/lib/http/2/buffer.rb

@@ -1,27 +1,24 @@
 module HTTP2
-
   # Simple binary buffer backed by string.
   #
   class Buffer < String
-
-    UINT32 = "N"
-    BINARY = "binary"
-    private_constant :UINT32, :BINARY
+    UINT32 = 'N'.freeze
+    private_constant :UINT32
 
     # Forces binary encoding on the string
-    def initialize(data = '')
-      super(data.force_encoding(BINARY))
+    def initialize(*)
+      super.force_encoding(Encoding::BINARY)
     end
 
     # Emulate StringIO#read: slice first n bytes from the buffer.
     #
     # @param n [Integer] number of bytes to slice from the buffer
     def read(n)
-      Buffer.new(slice!(0,n))
+      Buffer.new(slice!(0, n))
     end
 
     # Alias getbyte to readbyte
-    alias :readbyte :getbyte
+    alias_method :readbyte, :getbyte
 
     # Emulate StringIO#getbyte: slice first byte from buffer.
     def getbyte
@@ -34,5 +31,4 @@ module HTTP2
       read(4).unpack(UINT32).first
     end
   end
-
 end

data/lib/http/2/client.rb

@@ -1,5 +1,4 @@
 module HTTP2
-
   # HTTP 2.0 client connection class that implements appropriate header
   # compression / decompression algorithms and stream management logic.
   #
@@ -18,7 +17,6 @@ module HTTP2
   #     end
   #
   class Client < Connection
-
     # Initialize new HTTP 2.0 client object.
     def initialize(**settings)
       @stream_id    = 1
@@ -42,15 +40,12 @@ module HTTP2
 
     # Emit the connection preface if not yet
     def send_connection_preface
-      if @state == :waiting_connection_preface
-        @state = :connected
-        emit(:frame, CONNECTION_PREFACE_MAGIC)
+      return unless @state == :waiting_connection_preface
+      @state = :connected
+      emit(:frame, CONNECTION_PREFACE_MAGIC)
 
-        payload = @local_settings.select {|k,v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k]}
-        settings(payload)
-      end
+      payload = @local_settings.select { |k, v| v != SPEC_DEFAULT_CONNECTION_SETTINGS[k] }
+      settings(payload)
     end
-
   end
-
 end

data/lib/http/2/compressor.rb

@@ -1,101 +1,97 @@
 module HTTP2
-
   # Implementation of header compression for HTTP 2.0 (HPACK) format adapted
   # to efficiently represent HTTP headers in the context of HTTP 2.0.
   #
-  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09
+  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
   module Header
-
-    BINARY = 'binary'
-
     # To decompress header blocks, a decoder only needs to maintain a
-    # header table as a decoding context.
+    # dynamic table as a decoding context.
     # No other state information is needed.
     class EncodingContext
       include Error
 
       # @private
       # Static table
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#appendix-B
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#appendix-A
       STATIC_TABLE = [
-        [':authority',                  ''            ],
-        [':method',                     'GET'         ],
-        [':method',                     'POST'        ],
-        [':path',                       '/'           ],
-        [':path',                       '/index.html' ],
-        [':scheme',                     'http'        ],
-        [':scheme',                     'https'       ],
-        [':status',                     '200'         ],
-        [':status',                     '204'         ],
-        [':status',                     '206'         ],
-        [':status',                     '304'         ],
-        [':status',                     '400'         ],
-        [':status',                     '404'         ],
-        [':status',                     '500'         ],
-        ['accept-charset',              ''            ],
-        ['accept-encoding',             'gzip, deflate' ],
-        ['accept-language',             ''            ],
-        ['accept-ranges',               ''            ],
-        ['accept',                      ''            ],
-        ['access-control-allow-origin', ''            ],
-        ['age',                         ''            ],
-        ['allow',                       ''            ],
-        ['authorization',               ''            ],
-        ['cache-control',               ''            ],
-        ['content-disposition',         ''            ],
-        ['content-encoding',            ''            ],
-        ['content-language',            ''            ],
-        ['content-length',              ''            ],
-        ['content-location',            ''            ],
-        ['content-range',               ''            ],
-        ['content-type',                ''            ],
-        ['cookie',                      ''            ],
-        ['date',                        ''            ],
-        ['etag',                        ''            ],
-        ['expect',                      ''            ],
-        ['expires',                     ''            ],
-        ['from',                        ''            ],
-        ['host',                        ''            ],
-        ['if-match',                    ''            ],
-        ['if-modified-since',           ''            ],
-        ['if-none-match',               ''            ],
-        ['if-range',                    ''            ],
-        ['if-unmodified-since',         ''            ],
-        ['last-modified',               ''            ],
-        ['link',                        ''            ],
-        ['location',                    ''            ],
-        ['max-forwards',                ''            ],
-        ['proxy-authenticate',          ''            ],
-        ['proxy-authorization',         ''            ],
-        ['range',                       ''            ],
-        ['referer',                     ''            ],
-        ['refresh',                     ''            ],
-        ['retry-after',                 ''            ],
-        ['server',                      ''            ],
-        ['set-cookie',                  ''            ],
-        ['strict-transport-security',   ''            ],
-        ['transfer-encoding',           ''            ],
-        ['user-agent',                  ''            ],
-        ['vary',                        ''            ],
-        ['via',                         ''            ],
-        ['www-authenticate',            ''            ],
-      ].freeze
+        [':authority',                  ''],
+        [':method',                     'GET'],
+        [':method',                     'POST'],
+        [':path',                       '/'],
+        [':path',                       '/index.html'],
+        [':scheme',                     'http'],
+        [':scheme',                     'https'],
+        [':status',                     '200'],
+        [':status',                     '204'],
+        [':status',                     '206'],
+        [':status',                     '304'],
+        [':status',                     '400'],
+        [':status',                     '404'],
+        [':status',                     '500'],
+        ['accept-charset',              ''],
+        ['accept-encoding',             'gzip, deflate'],
+        ['accept-language',             ''],
+        ['accept-ranges',               ''],
+        ['accept',                      ''],
+        ['access-control-allow-origin', ''],
+        ['age',                         ''],
+        ['allow',                       ''],
+        ['authorization',               ''],
+        ['cache-control',               ''],
+        ['content-disposition',         ''],
+        ['content-encoding',            ''],
+        ['content-language',            ''],
+        ['content-length',              ''],
+        ['content-location',            ''],
+        ['content-range',               ''],
+        ['content-type',                ''],
+        ['cookie',                      ''],
+        ['date',                        ''],
+        ['etag',                        ''],
+        ['expect',                      ''],
+        ['expires',                     ''],
+        ['from',                        ''],
+        ['host',                        ''],
+        ['if-match',                    ''],
+        ['if-modified-since',           ''],
+        ['if-none-match',               ''],
+        ['if-range',                    ''],
+        ['if-unmodified-since',         ''],
+        ['last-modified',               ''],
+        ['link',                        ''],
+        ['location',                    ''],
+        ['max-forwards',                ''],
+        ['proxy-authenticate',          ''],
+        ['proxy-authorization',         ''],
+        ['range',                       ''],
+        ['referer',                     ''],
+        ['refresh',                     ''],
+        ['retry-after',                 ''],
+        ['server',                      ''],
+        ['set-cookie',                  ''],
+        ['strict-transport-security',   ''],
+        ['transfer-encoding',           ''],
+        ['user-agent',                  ''],
+        ['vary',                        ''],
+        ['via',                         ''],
+        ['www-authenticate',            ''],
+      ].each { |pair| pair.each(&:freeze).freeze }.freeze
 
       # Current table of header key-value pairs.
       attr_reader :table
 
       # Current encoding options
       #
-      #   :table_size  Integer  maximum header table size in bytes
+      #   :table_size  Integer  maximum dynamic table size in bytes
       #   :huffman     Symbol   :always, :never, :shorter
       #   :index       Symbol   :all, :static, :never
       attr_reader :options
 
       # Initializes compression context with appropriate client/server
-      # defaults and maximum size of the header table.
+      # defaults and maximum size of the dynamic table.
       #
       # @param options [Hash] encoding options
-      #   :table_size  Integer  maximum header table size in bytes
+      #   :table_size  Integer  maximum dynamic table size in bytes
       #   :huffman     Symbol   :always, :never, :shorter
       #   :index       Symbol   :all, :static, :never
       def initialize(**options)
@@ -115,32 +111,32 @@ module HTTP2
         other = EncodingContext.new(@options)
         t = @table
         l = @limit
-        other.instance_eval {
+        other.instance_eval do
           @table = t.dup              # shallow copy
           @limit = l
-        }
+        end
         other
       end
 
-      # Finds an entry in current header table by index.
+      # Finds an entry in current dynamic table by index.
       # Note that index is zero-based in this module.
       #
       # If the index is greater than the last index in the static table,
-      # an entry in the header table is dereferenced.
+      # an entry in the dynamic table is dereferenced.
       #
       # If the index is greater than the last header index, an error is raised.
       #
-      # @param index [Integer] zero-based index in the header table.
+      # @param index [Integer] zero-based index in the dynamic table.
       # @return [Array] +[key, value]+
       def dereference(index)
         # NOTE: index is zero-based in this module.
-        STATIC_TABLE[index] or
-          @table[index - STATIC_TABLE.size] or
-          raise CompressionError.new("Index too large")
+        value = STATIC_TABLE[index] || @table[index - STATIC_TABLE.size]
+        fail CompressionError, 'Index too large' unless value
+        value
       end
 
       # Header Block Processing
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-4.1
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-4.1
       #
       # @param cmd [Hash] { type:, name:, value:, index: }
       # @return [Array] +[name, value]+ header field that is added to the decoded header list
@@ -149,13 +145,13 @@ module HTTP2
 
         case cmd[:type]
         when :changetablesize
-          set_table_size(cmd[:value])
+          self.table_size = cmd[:value]
 
         when :indexed
           # Indexed Representation
           # An _indexed representation_ entails the following actions:
           # o  The header field corresponding to the referenced entry in either
-          # the static table or header table is added to the decoded header
+          # the static table or dynamic table is added to the decoded header
           # list.
           idx = cmd[:name]
 
@@ -163,14 +159,14 @@ module HTTP2
           emit = [k, v]
 
         when :incremental, :noindex, :neverindexed
-          # A _literal representation_ that is _not added_ to the header table
+          # A _literal representation_ that is _not added_ to the dynamic table
           # entails the following action:
           # o  The header field is added to the decoded header list.
 
-          # A _literal representation_ that is _added_ to the header table
+          # A _literal representation_ that is _added_ to the dynamic table
           # entails the following actions:
           # o  The header field is added to the decoded header list.
-          # o  The header field is inserted at the beginning of the header table.
+          # o  The header field is inserted at the beginning of the dynamic table.
 
           if cmd[:name].is_a? Integer
             k, v = dereference(cmd[:name])
@@ -183,19 +179,17 @@ module HTTP2
 
           emit = [cmd[:name], cmd[:value]]
 
-          if cmd[:type] == :incremental
-            add_to_table(emit)
-          end
+          add_to_table(emit) if cmd[:type] == :incremental
 
         else
-          raise CompressionError.new("Invalid type: #{cmd[:type]}")
+          fail CompressionError, "Invalid type: #{cmd[:type]}"
         end
 
         emit
       end
 
       # Plan header compression according to +@options [:index]+
-      #  :never   Do not use header table or static table reference at all.
+      #  :never   Do not use dynamic table or static table reference at all.
       #  :static  Use static table only.
       #  :all     Use all of them.
       #
@@ -207,9 +201,7 @@ module HTTP2
         noindex = [:static, :never].include?(@options[:index])
         headers.each do |h|
           cmd = addcmd(h)
-          if noindex && cmd[:type] == :incremental
-            cmd[:type] = :noindex
-          end
+          cmd[:type] = :noindex if noindex && cmd[:type] == :incremental
           commands << cmd
           process(cmd)
         end
@@ -217,12 +209,12 @@ module HTTP2
       end
 
       # Emits command for a header.
-      # Prefer static table over header table.
+      # Prefer static table over dynamic table.
       # Prefer exact match over name-only match.
       #
-      # +@options [:index]+ controls whether to use the header table,
+      # +@options [:index]+ controls whether to use the dynamic table,
       # static table, or both.
-      #  :never   Do not use header table or static table reference at all.
+      #  :never   Do not use dynamic table or static table reference at all.
       #  :static  Use static table only.
       #  :all     Use all of them.
       #
@@ -262,9 +254,9 @@ module HTTP2
         end
       end
 
-      # Alter header table size.
+      # Alter dynamic table size.
       #  When the size is reduced, some headers might be evicted.
-      def set_table_size(size)
+      def table_size=(size)
         @limit = size
         size_check(nil)
       end
@@ -272,51 +264,49 @@ module HTTP2
       # Returns current table size in octets
       # @return [Integer]
       def current_table_size
-        @table.inject(0){|r,(k,v)| r += k.bytesize + v.bytesize + 32 }
+        @table.inject(0) { |r, (k, v)| r + k.bytesize + v.bytesize + 32 }
       end
 
       private
 
-      # Add a name-value pair to the header table.
+      # Add a name-value pair to the dynamic table.
       # Older entries might have been evicted so that
-      # the new entry fits in the header table.
+      # the new entry fits in the dynamic table.
       #
       # @param cmd [Array] +[name, value]+
       def add_to_table(cmd)
-        if size_check(cmd)
-          @table.unshift(cmd)
-        end
+        return unless size_check(cmd)
+        @table.unshift(cmd)
       end
 
-      # To keep the header table size lower than or equal to @limit,
-      # remove one or more entries at the end of the header table.
+      # To keep the dynamic table size lower than or equal to @limit,
+      # remove one or more entries at the end of the dynamic table.
       #
       # @param cmd [Hash]
-      # @return [Boolean] whether +cmd+ fits in the header table.
+      # @return [Boolean] whether +cmd+ fits in the dynamic table.
       def size_check(cmd)
         cursize = current_table_size
         cmdsize = cmd.nil? ? 0 : cmd[0].bytesize + cmd[1].bytesize + 32
 
-        while cursize + cmdsize > @limit do
+        while cursize + cmdsize > @limit
           break if @table.empty?
 
-          last_index = @table.size - 1
           e = @table.pop
           cursize -= e[0].bytesize + e[1].bytesize + 32
         end
 
-        return cmdsize <= @limit
+        cmdsize <= @limit
       end
     end
 
     # Header representation as defined by the spec.
     HEADREP = {
-      indexed:      {prefix: 7, pattern: 0x80},
-      incremental:  {prefix: 6, pattern: 0x40},
-      noindex:      {prefix: 4, pattern: 0x00},
-      neverindexed: {prefix: 4, pattern: 0x10},
-      changetablesize: {prefix: 5, pattern: 0x20},
-    }
+      indexed:      { prefix: 7, pattern: 0x80 },
+      incremental:  { prefix: 6, pattern: 0x40 },
+      noindex:      { prefix: 4, pattern: 0x00 },
+      neverindexed: { prefix: 4, pattern: 0x10 },
+      changetablesize: { prefix: 5, pattern: 0x20 },
+    }.each_value(&:freeze).freeze
 
     # Predefined options set for Compressor
     # http://mew.org/~kazu/material/2014-hpack.pdf
@@ -336,14 +326,14 @@ module HTTP2
         @cc = EncodingContext.new(options)
       end
 
-      # Set header table size in EncodingContext
-      # @param size [Integer] new header table size
-      def set_table_size(size)
-        @cc.set_table_size(size)
+      # Set dynamic table size in EncodingContext
+      # @param size [Integer] new dynamic table size
+      def table_size=(size)
+        @cc.table_size = size
       end
 
       # Encodes provided value via integer representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-6.1
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.1
       #
       #  If I < 2^N - 1, encode I on N bits
       #  Else
@@ -359,15 +349,15 @@ module HTTP2
       # @return [String] binary string
       def integer(i, n)
         limit = 2**n - 1
-        return [i].pack('C') if (i < limit)
+        return [i].pack('C') if i < limit
 
         bytes = []
-        bytes.push limit if !n.zero?
+        bytes.push limit unless n.zero?
 
         i -= limit
-        while (i >= 128) do
+        while (i >= 128)
           bytes.push((i % 128) + 128)
-          i = i / 128
+          i /= 128
         end
 
         bytes.push i
@@ -375,7 +365,7 @@ module HTTP2
       end
 
       # Encodes provided value via string literal representation.
-      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-09#section-6.2
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.2
       #
       # * The string length, defined as the number of bytes needed to store
       #   its UTF-8 representation, is represented as an integer with a seven
@@ -397,7 +387,7 @@ module HTTP2
       def string(str)
         plain, huffman = nil, nil
         unless @cc.options[:huffman] == :always
-          plain = integer(str.bytesize, 7) << str.dup.force_encoding(BINARY)
+          plain = integer(str.bytesize, 7) << str.dup.force_encoding(Encoding::BINARY)
         end
         unless @cc.options[:huffman] == :never
           huffman = Huffman.new.encode(str)
@@ -424,12 +414,12 @@ module HTTP2
 
         case h[:type]
         when :indexed
-          buffer << integer(h[:name]+1, rep[:prefix])
+          buffer << integer(h[:name] + 1, rep[:prefix])
         when :changetablesize
           buffer << integer(h[:value], rep[:prefix])
         else
           if h[:name].is_a? Integer
-            buffer << integer(h[:name]+1, rep[:prefix])
+            buffer << integer(h[:name] + 1, rep[:prefix])
           else
             buffer << integer(0, rep[:prefix])
             buffer << string(h[:name])
@@ -454,7 +444,7 @@ module HTTP2
 
         # Literal header names MUST be translated to lowercase before
         # encoding and transmission.
-        headers.map! {|hk,hv| [hk.downcase, hv] }
+        headers.map! { |hk, hv| [hk.downcase, hv] }
 
         commands = @cc.encode(headers)
         commands.each do |cmd|
@@ -478,10 +468,10 @@ module HTTP2
         @cc = EncodingContext.new(options)
       end
 
-      # Set header table size in EncodingContext
-      # @param size [Integer] new header table size
-      def set_table_size(size)
-        @cc.set_table_size(size)
+      # Set dynamic table size in EncodingContext
+      # @param size [Integer] new dynamic table size
+      def table_size=(size)
+        @cc.table_size = size
       end
 
       # Decodes integer value from provided buffer.
@@ -494,7 +484,7 @@ module HTTP2
         i = !n.zero? ? (buf.getbyte & limit) : 0
 
         m = 0
-        while byte = buf.getbyte do
+        while (byte = buf.getbyte)
           i += ((byte & 127) << m)
           m += 7
 
@@ -513,10 +503,9 @@ module HTTP2
         huffman = (buf.readbyte(0) & 0x80) == 0x80
         len = integer(buf, 7)
         str = buf.read(len)
-        str.bytesize == len or raise CompressionError.new("string too short")
-        huffman and str = Huffman.new.decode(Buffer.new(str))
-        str = str.force_encoding('utf-8')
-        str
+        fail CompressionError, 'string too short' unless str.bytesize == len
+        str = Huffman.new.decode(Buffer.new(str)) if huffman
+        str.force_encoding(Encoding::UTF_8)
       end
 
       # Decodes header command from provided buffer.
@@ -527,18 +516,18 @@ module HTTP2
         peek = buf.readbyte(0)
 
         header = {}
-        header[:type], type = HEADREP.select do |t, desc|
+        header[:type], type = HEADREP.find do |_t, desc|
           mask = (peek >> desc[:prefix]) << desc[:prefix]
           mask == desc[:pattern]
-        end.first
+        end
 
-        header[:type] or raise CompressionError
+        fail CompressionError unless header[:type]
 
         header[:name] = integer(buf, type[:prefix])
 
         case header[:type]
         when :indexed
-          header[:name] == 0 and raise CompressionError.new
+          fail CompressionError if header[:name] == 0
           header[:name] -= 1
         when :changetablesize
           header[:value] = header[:name]
@@ -560,10 +549,9 @@ module HTTP2
       # @return [Array] +[[name, value], ...]+
       def decode(buf)
         list = []
-        list << @cc.process(header(buf)) while !buf.empty?
+        list << @cc.process(header(buf)) until buf.empty?
         list.compact
       end
     end
-
   end
 end