spyder 0.1.2 → 0.3.0.pre.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3417dd82aa219dd2526c0fb01be1f6e9c58723651bac784b2f082a4c8d3b5f20
-  data.tar.gz: eca6629c49c0048f7304da5c71f8701d38b1a24ef4a160f923bf5267d0cea628
+  metadata.gz: 2e1ade7f9c9ee1b99448fc6a0fb8addcbbca80a2696581b1bb4fa05c27ea534a
+  data.tar.gz: 075d91b41bdd5a7264bfadd3e014ef67b7c311545417b1503c9a245935f12860
 SHA512:
-  metadata.gz: d97926b4bc3a3064d7e6224c0bbb61ec2a225207f766802be5821db8d9b092eba60e92aec37b5012843e073999aa057c79e946551503e680dcf7c2e327013f32
-  data.tar.gz: 51a1d5d5a6b4e8d7ba2598ddcf674e1acb224e35fa77a2c53f90a97f936709bc52274f9f92cef492d93f96ef3095758a7e946e63cc2db7720859a4c654096509
+  metadata.gz: f0cc009cdbf9d1ab3bf184be0214c6d1e0366b6d0823dc6df8c2b548db4e2b631d972f8e7a2dd2ec9fabfdcb2b6135e4ba1c79d3276d6bc5864005df73f32750
+  data.tar.gz: ba21a6413f6cf9ffe290806cd7ee7b96c877b592243d3549caaa374dd455a40037e2f240f41743c83fcc753f0cf97ad682892f2c0cfe4f96d3f99ad50f77bf5c

data/lib/spyder/basic_server.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spyder
+  class BasicServer
+    attr_accessor :router
+
+    def initialize(router)
+      @router = router
+      @middleware = []
+    end
+
+    def process_request(request)
+      mids = @middleware + [[RouterApp, @router]]
+      app = nil
+
+      loop do
+        klass, args = mids.pop
+        break unless klass
+        app = klass.new(args, app)
+      end
+
+      app.call({}, request)
+    end
+
+    def add_middleware(callable, args=[])
+      @middleware << [callable, args]
+    end
+  end
+end

data/lib/spyder/rack_adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'spyder'
+
+module Spyder
+  class RackServer < BasicServer
+    attr_accessor :router
+
+    def initialize(router: Router.new)
+      super(router)
+    end
+
+    def call(env)
+      qs = env[Rack::QUERY_STRING]
+
+      request = Request.new
+      request.path = (!qs || qs.empty? ? env[Rack::PATH_INFO] : "#{env[Rack::PATH_INFO]}?#{qs}")
+      request.verb = env[Rack::REQUEST_METHOD]
+      request.http_version = env['HTTP_VERSION']
+      request.io = env['rack.input']
+
+      env.each do |key, value|
+        next unless key.start_with?('HTTP_') && key != 'HTTP_VERSION'
+
+        header_name = key[5..].downcase.tr('_', '-')
+        request.add_header(header_name, value)
+      end
+
+      response = process_request(request)
+
+      [
+        response.code,
+        # response.headers.ordered.map { |k, v| ["HTTP_#{k.tr('-', '_').upcase}", v] },
+        response.headers.ordered,
+        [response.body]
+      ]
+    end
+  end
+end

data/lib/spyder/request.rb

@@ -7,7 +7,7 @@ module Spyder
     attr_accessor :verb
     attr_accessor :path
     attr_accessor :headers
-    attr_accessor :protocol, :remote_address
+    attr_accessor :http_version, :remote_address
     attr_accessor :io
 
     def_delegators :@headers, :ordered, :dict, :add_header
@@ -73,6 +73,16 @@ module Spyder
       len ? io.read(Integer(len)) : io.read # FIXME:
     end
 
+    def debug_dump(include_body: false)
+      lines = ["verb=#{@verb}\npath=#{@path}\nhttp_version=#{@http_version}"]
+      lines << "has #{@headers.dict.length} headers"
+      @headers.dict.each do |name, value|
+        lines << "\t#{name} = #{value}"
+      end
+      lines << "has body: #{has_body? ? 'yes' : 'no'}"
+      lines.join("\n")
+    end
+
     def has_body?
       dict['transfer-encoding'] != nil || dict['content-length'] != nil
     end

data/lib/spyder/response.rb

@@ -4,6 +4,7 @@ module Spyder
   class Response
     attr_reader :code
     attr_accessor :body
+    attr_accessor :hijack
     attr_reader :headers
     attr_writer :reason_sentence
 
@@ -60,8 +61,10 @@ module Spyder
       ]
     end.freeze
 
-    def initialize
-      self.code = :ok
+    def initialize(code: :ok)
+      @body = nil
+      @hijack = false
+      self.code = code
       @headers = HeaderStore.new(:response)
     end
 

data/lib/spyder/router.rb

@@ -2,10 +2,19 @@
 
 module Spyder
   class Router
-    attr_accessor :fallback_route
+    attr_accessor :fallback_stack
 
     def initialize
       @routes = Hash.new { |k, v| k[v] = [] }
+      @fallback_stack = []
+    end
+
+    def add_route_method(verb, matcher, obj, method_name)
+      h = proc do |req, rq|
+        obj.public_send(method_name, req, rq)
+      end
+      
+      add_route(verb, matcher, &h)
     end
 
     def add_route(verb, matcher, &handler)
@@ -14,6 +23,12 @@ module Spyder
       @routes[verb.to_s.upcase] << [matcher, handler]
     end
 
+    def add_fallback(callable = nil, &blk)
+      raise "Provide either a callable or a block, but not both" if callable && block_given?
+
+      @fallback_stack << (block_given? ? blk : callable)
+    end
+
     def call(ctx, request)
       only_path = request.path_info
 
@@ -26,7 +41,16 @@ module Spyder
         end
       end
 
-      match_data ? handler.call(request, match_data) : Response.make_generic(:not_found)
+      response = match_data ? handler.call(request, match_data) : nil
+      return response if response.is_a?(Response)
+
+      fallback_stack.each do |blk|
+        response = blk.call(request)
+
+        return response if response.is_a?(Response)
+      end
+
+      Response.make_generic(:not_found)
     end
   end
 

data/lib/spyder/server.rb

@@ -1,84 +1,100 @@
 # frozen_string_literal: true
 
 module Spyder
-  class Server
+  class Server < BasicServer
     attr_accessor :router
 
     def initialize(bind, port, router: Router.new, max_threads: 4, tcp_backlog: 10)
+      super(router)
+
       @server = TCPServer.new(bind, port)
       @tcp_backlog = tcp_backlog
       @max_threads = max_threads
-      @middleware = []
-      @threads = []
+      @max_queue_size = max_threads * tcp_backlog
+      @tp_read, @tp_write = IO.pipe
       @tp_sync = Mutex.new
-      @router = router
+      @waiting_clients = []
+      @threads = max_threads.times.map { create_request_handler_thread }
     end
 
-    def add_middleware(callable, args)
-      @middleware << [callable, args]
+    def create_request_handler_thread
+      Thread.new do
+        loop do
+          @tp_read.read(1)
+          client = nil
+
+          @tp_sync.synchronize do
+            client = @waiting_clients.shift
+          end
+
+          handle_new_client(client)
+        end
+      end
+    end
+
+    def handle_new_client(client)
+      error, response = nil
+
+      request = read_client_request(client)
+
+      begin
+        response = process_request(request)
+      rescue Exception => e
+        error = e
+      end
+
+      if error
+        puts "Request errored in spyder. Error dump:"
+        puts error.full_message
+        puts "Request dump:\n#{request.debug_dump}"
+
+        response = Response.make_generic :internal_server_error
+      end
+
+      dispatch_response(client, response)
+
+      if !error && response&.hijack
+        response.hijack.call(client)
+      else
+        client.close rescue nil
+      end
     end
 
     def start
-      busy_threads = 0
       @server.listen(@tcp_backlog)
 
       loop do
         time_start = Process.clock_gettime(:CLOCK_MONOTONIC, :float_second)
         loop do
-          current_busy = @tp_sync.synchronize { busy_threads }
-          break if current_busy < @max_threads
+          queue_size = nil
+          @tp_sync.synchronize do
+            queue_size = @waiting_clients.length
+          end
+
+          break if queue_size < @max_queue_size #  current_busy < @max_threads
           sleep(0)
           current_time = Process.clock_gettime(:CLOCK_MONOTONIC, :float_second)
           if (current_time - time_start) > 1.0
-            # puts "Waiting a long time: #{(current_time - time_start)}"
+            puts "Waiting a long time: #{(current_time - time_start)}"
             sleep 0.2
           end
         end
 
-        client = @server.accept
-        @tp_sync.synchronize { busy_threads += 1 }
-
-        Thread.new do
-          begin
-            error = nil
-            begin
-              process_new_client(client)
-            rescue Exception => e
-              error = e
-            end
-
-            if error
-              puts error.full_message
-
-              response = Response.make_generic :internal_server_error
-              dispatch_response(client, response)
-            end
-
-            client.close rescue nil
-          ensure
-            @tp_sync.synchronize { busy_threads -= 1 }
-          end
+        client_socket = @server.accept
+        @tp_sync.synchronize do
+          @waiting_clients << client_socket
         end
-      end
-    end
 
-    def process_request(request)
-      mids = @middleware + [[RouterApp, @router]]
-      app = nil
-      loop do
-        klass, args = mids.pop
-        break unless klass
-        app = klass.new(args, app)
+        @tp_write.write(1)
       end
-
-      app.call({}, request)
     end
 
-    def process_new_client(socket)
-      verb, path, protocol = read_line(socket).split(' ')
+    def read_client_request(socket)
+      verb, path, http_version = read_line(socket).split(' ', 3)
       request = Request.new
       request.path = path
       request.verb = verb
+      request.http_version = http_version
       request.io = socket
 
       loop do
@@ -90,24 +106,25 @@ module Spyder
         request.add_header(name, value)
       end
 
-      response = process_request(request)
-
-      dispatch_response(socket, response)
+      request
     end
 
     def dispatch_response(socket, response)
       content_length = response.headers.dict['content-length']
       if !content_length && response.body && response.body.is_a?(String)
         content_length = response.body.length
+        response.set_header 'content-length', content_length.to_s
+      elsif !content_length && (200..203) === response.code
+        response.set_header 'content-length', '0'
       end
 
+      response.set_header('connection', 'close') unless response.headers.dict['connection']
+
       begin
         socket.write("HTTP/1.1 #{response.code} #{response.reason_sentence.b}\r\n")
         response.headers.ordered.each do |name, value|
           socket.write("#{name.b}: #{value.b}\r\n")
         end
-        socket.write("connection: close\r\n") # FIXME:
-        socket.write("content-length: #{content_length}\r\n") if content_length
         socket.write("\r\n")
 
         if response.body
@@ -120,6 +137,8 @@ module Spyder
         # socket closed. So what?
         socket.close rescue nil
       end
+
+      response
     end
 
     def read_line(socket)

data/lib/spyder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spyder
-  VERSION = '0.1.2'
+  VERSION = '0.3.0-beta1'
 end

data/lib/spyder/web/file_server.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Spyder
+  module Web
+    class FileServer
+      attr_reader :base_paths
+      attr_reader :default_index
+
+      def initialize(paths, index: nil)
+        @default_index = index
+        @base_paths = Array(paths).map do |path|
+          if path[0] == '/'
+            path
+          else
+            File.expand_path(File.join(Dir.pwd, path))
+          end
+        end
+      end
+
+      def call(request)
+        return unless request.verb == 'GET'
+
+        input_path = request.path_info
+        input_path = @default_index if request.path == '/' && @default_index
+
+        req_path = safe_request_path(input_path)
+        full_path = nil
+        return unless @base_paths.any? do |base|
+          fp = File.join(base, *req_path)
+          next unless File.file?(fp)
+          full_path = fp
+
+          true
+        end
+
+        st = File.readable?(full_path) ? File.stat(full_path) : nil
+
+        return unless st && %w[file link].include?(st.ftype)
+
+        etag = "\"#{"%xT-%x0" % [st.mtime, st.size]}\""
+
+        resp = serve_not_modified_response(request, st, etag)
+        return resp if resp
+
+        resp = Spyder::Response.new
+        resp.add_standard_headers
+        resp.set_header 'last-modified', st.mtime.httpdate
+        resp.set_header 'etag', etag
+        resp.set_header 'cache-control', 'public, must-revalidate, max-age=0'
+
+        File.open full_path do |fp|
+          mime = Marcel::MimeType.for(fp)
+          if mime == 'application/octet-stream' || mime == 'text/plain'
+            mime = Marcel::MimeType.for(name: req_path.last)
+          end
+
+          resp.set_header('content-type', mime) if mime
+
+          fp.rewind
+          resp.body = fp.read
+        end
+
+        resp
+      end
+
+      private
+
+      def serve_not_modified_response(request, st, etag)
+        if_etag = request.headers.dict['if-none-match']
+        if_modified_since = request.headers.dict['if-modified-since']
+
+        return unless if_etag || if_modified_since
+
+        resp = Spyder::Response.new
+        resp.add_standard_headers
+        resp.code = 304
+
+        return resp if if_etag && if_etag == etag
+
+        if_ms = if_modified_since ? Time.parse(if_modified_since) : nil
+
+        (if_ms && Time.at(st.mtime.to_i) <= if_ms) ? resp  : nil
+      end
+
+      def safe_request_path(path)
+        path.split('/').reject do |component|
+          component == '..' || component == '' || component == '.'
+        end
+      end
+    end
+  end
+end

data/lib/spyder/web_socket.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Spyder
+  class WebSocket
+    WS_CONST = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+    class Frame
+      def initialize
+      end
+
+      def decode(raw_data)
+        fin = raw_data[0] & 1
+        rsv = (raw_data[0] & 0b0111) >> 1
+      end
+    end
+
+    def initialize
+      @socket = nil
+      @on_start = nil
+      @on_message = nil
+      @on_close = nil
+
+      @streaming_buffer = WebSocketStreamingBuffer.new do |frame, mode, fragmented, last_fragment|
+        @on_message.call(frame, mode) unless fragmented
+      end
+      @streaming_buffer.on_close = proc do
+        @socket.close rescue nil
+      end
+    end
+
+    def send_text(data)
+      send_data(data, :text)
+    end
+
+    def send_binary(data)
+      send_data(data, :binary)
+    end
+
+    def send_data(data, mode)
+      data = data.b
+
+      length = data.length
+      buffer = String.new(encoding: 'ascii-8bit', capacity: length + 32)
+      buffer += ((1 << 7) | (mode == :binary ? 2 : 1)).chr
+      if length < 126
+        buffer += length.chr
+      elsif length <= 0xFFFF
+        buffer += [126, length].pack('CS>')
+      else
+        buffer += [127, length].pack('CQ>')
+      end
+
+      @socket.write(buffer)
+      @socket.write(data)
+    end
+
+    def on_close(&blk)
+      @on_close = blk
+    end
+
+    def on_message(&blk)
+      @on_message = blk
+    end
+
+    def on_start(&blk)
+      @on_start = blk
+    end
+
+    def hijacked!(socket)
+      @socket = socket
+      puts "websocket hijacked! #{socket}"
+      @thread = Thread.start do
+        self.threaded_start!
+      end
+    end
+
+    def self.upgrade_websocket_request(request)
+      ws_key = request.headers.dict['sec-websocket-key']
+      return unless ws_key && request.headers.dict['upgrade'] == 'websocket'
+
+      conns = request.headers.dict.fetch('connection', '').split(' ').map(&:strip)
+      return unless conns.include?('Upgrade')
+
+      ws_version = request.headers.dict['sec-websocket-version'] # expect: 13
+      return unless ws_version
+
+      protocols = request.headers.dict['sec-websocket-protocol']
+      protocols = protocols.split(',').map(&:strip) if protocols
+
+      extensions = request.headers.dict['sec-websocket-extensions']
+      extensions = extensions.split(';').map(&:strip) if extensions
+
+      decoded_key = Base64.strict_decode64(ws_key) rescue nil
+      return unless decoded_key&.length == 16
+
+      response_key = Base64.strict_encode64(
+        OpenSSL::Digest::SHA1.digest("#{ws_key}#{WS_CONST}")
+      )
+
+      ws = new
+
+      chosen_proto = yield(ws, protocols) if (block_given? && protocols)
+      chosen_proto = protocols.first if !chosen_proto && protocols
+
+      resp = Spyder::Response.new(code: 101)
+      resp.add_standard_headers
+      resp.set_header 'connection', 'Upgrade'
+      resp.set_header 'upgrade', 'websocket'
+      resp.set_header('sec-websocket-protocol', chosen_proto) if chosen_proto
+      resp.set_header 'sec-websocket-accept', response_key
+
+      resp.hijack = proc { |client_socket| ws.hijacked!(client_socket) }
+
+      [resp, ws]
+    end
+
+    def threaded_start!
+      @on_start.call if @on_start
+
+      while !@socket.closed? && !@socket.eof?
+        data = nil
+        begin
+          data = @socket.read_nonblock(16 * 1024)
+        rescue IO::WaitReadable
+          IO.select([@socket], [], [@socket])
+        end
+
+        next unless data
+
+        puts "ws: read #{data.length} bytes"
+        @streaming_buffer.feed(data)
+      end
+
+      @on_close.call unless @on_close
+    end
+  end
+end

data/lib/spyder/web_socket_streaming_buffer.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Spyder
+  class WebSocketStreamingBuffer
+    attr_reader :buffer
+    attr_accessor :on_close
+
+    def initialize(&frame_callback)
+      @frame_callback = frame_callback
+      @on_close = nil
+      @buffer = []
+      _reset
+    end
+
+    def feed(buf)
+      @buffer += buf.bytes
+
+      # printable = buf.bytes.map{ |x| x.to_s(16).rjust(2, '0').upcase }.join(' ')
+      # puts "Got #{buf.bytes.length} more bytes: [#{printable}]"
+
+      iterations = 0
+      loop do
+        _flush
+
+        iterations += 1
+        if iterations > 1_000
+          raise "Watchdog error: got stuck on a loop of #{iterations} iterations."
+        end
+
+        break if (@buffer.length == 0 && !@need_buffer_length) ||
+          (@need_buffer_length && @buffer.length < @need_buffer_length)
+      end
+    end
+
+    private
+
+    def _reset
+      @state = :initial
+      @mask = nil
+      @opcode = nil
+      @data_mode = nil
+      @payload_length = nil
+      @need_buffer_length = nil
+      @flag_fin = nil
+      @fragmented = false
+      @fragmented_total_size = nil
+    end
+
+    def _flush
+      send(:"_flush_#{@state}")
+    end
+
+    def _flush_data
+      return unless @buffer.length >= @payload_length
+
+      data = if @mask
+        (0...@payload_length).map do |i|
+          @buffer[i] ^ @mask[i & 3]
+        end
+      else
+        @buffer[0...@payload_length]
+      end
+
+      last_fragment = @fragmented && @flag_fin
+      @frame_callback.call(data, @data_mode, @fragmented, last_fragment)
+
+      @buffer.shift(@payload_length)
+
+      if @fragmented && !last_fragment
+        @need_buffer_length = 2
+        @opcode = nil
+        @payload_length = nil
+        @state = "initial"
+      else
+        _reset
+      end
+    end
+
+    def close_with_error(msg)
+      @socket.close rescue nil
+
+      puts "Closing websocket: #{msg}"
+
+      @on_close.call if @on_close
+
+      _reset
+
+      @state = :closed
+      @socket = nil
+      @buffer = nil
+    end
+
+    def _flush_readhdr
+      return unless @buffer.length >= @need_buffer_length
+
+      @flag_fin = ((@buffer[0] & 0x80) != 0)
+      @opcode = (@buffer[0] & 0xF)
+      data_len = (@buffer[1] & 0x7F)
+      mask_flag = ((@buffer[1] & 0x80) != 0)
+
+      is_control_frame = ((@opcode & 8) != 0)
+      if is_control_frame && (data_len > 125 || !@flag_fin)
+        # Control frames must not be fragmented and must be <= 125 bytes in size
+        return close_with_error("Control frame invalid state")
+      end
+
+      if @fragmented && !is_control_frame && @opcode != 0
+        # We're in the middle of a fragmented frame and received a non-control
+        # frame. That's an error.
+        return close_with_error("Got non-control frame during fragmented frame.")
+      end
+
+      if !@fragmented && !@flag_fin && !is_control_frame
+        @fragmented = true
+        @fragmented_total_size = 0
+      end
+
+      shift_length = 2
+
+      @payload_length = if data_len == 127
+        shift_length += 8
+        @buffer[2...10].pack('C*').unpack('Q>').first
+      elsif data_len == 126
+        shift_length += 2
+        @buffer[2...4].pack('C*').unpack('S>').first
+      else
+        shift_length += 0
+        data_len
+      end
+
+      if mask_flag
+        @mask = @buffer[shift_length...(shift_length + 4)].pack('C*').bytes
+        shift_length += 4
+      else
+        @mask = nil
+      end
+
+      @fragmented_total_size += @payload_length if @fragmented
+
+      fgr = nil
+      fgr = ", fgr=#{@fragmented_total_size}" if @fragmented
+      puts "frame(code=#{@opcode}, len=#{@payload_length}, fin=#{@flag_fin}#{fgr})"
+
+      @buffer.shift(shift_length)
+      @need_buffer_length = ((0..2) === @opcode ? @payload_length : nil)
+
+      case @opcode
+      when 0x0 # continuation
+        @state = "data"
+      when 0x1 # text frame
+        @state = "data"
+        @data_mode = :text
+      when 0x2 # binary frame
+        @state = "data"
+        @data_mode = :binary
+      when (0x3..0x7) # reserved
+        unexpected_opcode(@opcode)
+      when 0x8 # connection close
+        @on_close.call if @on_close
+
+        _reset
+      when 0x9 # ping
+        # TODO: send pong?
+      when 0xA # pong
+        puts "WS: got pong!"
+
+        _reset
+      else
+        unexpected_opcode(@opcode)
+      end
+    end
+
+    def _flush_initial
+      return unless @buffer.length >= 2
+
+      data_len = (@buffer[1] & 0x7F)
+      mask_flag = (@buffer[1] & 0x80)
+
+      @need_buffer_length = 2 + (mask_flag ? 4 : 0) + (
+        data_len == 127 ? 8 : (data_len == 126 ? 2 : 0)
+      )
+
+      @state = "readhdr"
+      _flush
+    end
+
+    def unexpected_opcode opcode
+      puts "WS: unexpected opcode #{opcode}"
+      exit 1
+    end
+  end
+end

data/lib/spyder.rb

@@ -12,4 +12,14 @@ require 'spyder/header_store'
 require 'spyder/request'
 require 'spyder/response'
 require 'spyder/router'
+require 'spyder/basic_server'
 require 'spyder/server'
+require 'spyder/web_socket_streaming_buffer'
+require 'spyder/web_socket'
+
+# spyder-web
+require 'marcel'
+require 'base64'
+require 'openssl'
+
+require 'spyder/web/file_server'

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: spyder
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0.pre.beta1
 platform: ruby
 authors:
 - André D. Piske
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: mustermann
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: marcel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Spyder Web
 email: andrepiske@gmail.com
 executables: []
@@ -32,18 +59,22 @@ extra_rdoc_files: []
 files:
 - lib/examples/simplest_server/server.rb
 - lib/spyder.rb
+- lib/spyder/basic_server.rb
 - lib/spyder/error.rb
 - lib/spyder/header_store.rb
+- lib/spyder/rack_adapter.rb
 - lib/spyder/request.rb
 - lib/spyder/response.rb
 - lib/spyder/router.rb
 - lib/spyder/server.rb
 - lib/spyder/version.rb
+- lib/spyder/web/file_server.rb
+- lib/spyder/web_socket.rb
+- lib/spyder/web_socket_streaming_buffer.rb
 homepage: https://github.com/andrepiske/spyder
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -58,8 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 4.0.23
 specification_version: 4
 summary: Spyder
 test_files: []