eui-ruby 0.1.0

data/lib/eui/websocket.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+require 'base64'
+require 'securerandom'
+require_relative 'errors'
+require_relative 'proto'
+
+module EUI
+  # The server half of RFC 6455, with only what an EUI session needs.
+  #
+  # A session carries **binary** frames and nothing else: a text frame is
+  # not a protocol extension point, it is a sign that something other than
+  # an EUI client is talking, and the session ends
+  # (`spec/01-transport.md` §2.3).
+  class WebSocket
+    GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+    MAX_MESSAGE = Proto::Limits::MAX_FRAME_BYTES + 16
+
+    CONTINUATION = 0x0
+    TEXT = 0x1
+    BINARY = 0x2
+    CLOSE = 0x8
+    PING = 0x9
+    PONG = 0xA
+
+    class ClosedError < Error; end
+    class ProtocolError < Error; end
+
+    attr_reader :path, :headers
+
+    def initialize(socket, path:, headers:)
+      @socket = socket
+      @path = path
+      @headers = headers
+      @write_lock = Mutex.new
+      @closed = false
+    end
+
+    # Answer the upgrade. The key is not a secret and proves nothing: it is
+    # there so that a cache between the two ends cannot mistake this for a
+    # reply it may serve to somebody else.
+    def self.accept(socket, path:, headers:)
+      key = headers['sec-websocket-key']
+      raise ProtocolError, 'no Sec-WebSocket-Key' unless key
+
+      accept = Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
+      socket.write(
+        "HTTP/1.1 101 Switching Protocols\r\n" \
+        "Upgrade: websocket\r\n" \
+        "Connection: Upgrade\r\n" \
+        "Sec-WebSocket-Accept: #{accept}\r\n\r\n"
+      )
+      new(socket, path: path, headers: headers)
+    end
+
+    def closed? = @closed
+
+    # The next application message, or nil once the peer has gone.
+    # Control frames are answered here and never surface.
+    def recv
+      message = +''
+      message.force_encoding(Encoding::BINARY)
+      kind = nil
+
+      loop do
+        frame = read_frame
+        return nil if frame.nil?
+
+        opcode, payload, fin = frame
+        case opcode
+        when CLOSE
+          send_close(1000)
+          return nil
+        when PING
+          send_frame(PONG, payload)
+          next
+        when PONG
+          next
+        when TEXT, BINARY
+          raise ProtocolError, 'a frame arrived inside a fragmented message' unless message.empty?
+
+          kind = opcode
+          message << payload
+        when CONTINUATION
+          raise ProtocolError, 'a continuation with nothing to continue' if kind.nil?
+
+          message << payload
+        else
+          raise ProtocolError, "unknown opcode #{opcode}"
+        end
+
+        raise ProtocolError, 'message too large' if message.bytesize > MAX_MESSAGE
+        next unless fin
+
+        return [kind == TEXT ? :text : :binary, message]
+      end
+    end
+
+    def send_binary(data) = send_frame(BINARY, data)
+
+    def send_close(code = 1000, reason = '')
+      return if @closed
+
+      payload = [code].pack('n') + reason.to_s.byteslice(0, 123).to_s
+      send_frame(CLOSE, payload)
+      @closed = true
+    rescue Error, SystemCallError, IOError
+      @closed = true
+    end
+
+    def close
+      send_close
+      @socket.close
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    private
+
+    def send_frame(opcode, payload)
+      payload = payload.to_s.b
+      header = +''
+      header.force_encoding(Encoding::BINARY)
+      header << (0x80 | opcode).chr
+      len = payload.bytesize
+      if len < 126
+        header << len.chr
+      elsif len < 65_536
+        header << 126.chr << [len].pack('n')
+      else
+        header << 127.chr << [len].pack('Q>')
+      end
+      @write_lock.synchronize do
+        raise ClosedError, 'the socket is closed' if @socket.closed?
+
+        @socket.write(header, payload)
+      end
+    rescue SystemCallError, IOError => e
+      @closed = true
+      raise ClosedError, e.message
+    end
+
+    def read_frame
+      head = read_exactly(2)
+      return nil if head.nil?
+
+      b0, b1 = head.bytes
+      fin = (b0 & 0x80) != 0
+      raise ProtocolError, 'reserved bits set' if (b0 & 0x70) != 0
+
+      opcode = b0 & 0x0F
+      masked = (b1 & 0x80) != 0
+      # Every frame from a client is masked; one that is not is either a
+      # proxy rewriting traffic or something that is not a browser stack.
+      raise ProtocolError, 'a client frame must be masked' unless masked
+
+      len = b1 & 0x7F
+      len = read_exactly(2).unpack1('n') if len == 126
+      len = read_exactly(8).unpack1('Q>') if len == 127
+      raise ProtocolError, 'frame too large' if len > MAX_MESSAGE
+
+      mask = read_exactly(4)
+      payload = len.zero? ? +'' : read_exactly(len)
+      return nil if payload.nil?
+
+      [opcode, unmask(payload, mask), fin]
+    end
+
+    def unmask(payload, mask)
+      return payload if payload.empty?
+
+      key = mask.bytes
+      out = payload.dup
+      out.force_encoding(Encoding::BINARY)
+      bytes = out.bytes
+      bytes.each_with_index { |b, i| bytes[i] = b ^ key[i & 3] }
+      bytes.pack('C*')
+    end
+
+    def read_exactly(count)
+      data = +''
+      data.force_encoding(Encoding::BINARY)
+      while data.bytesize < count
+        chunk = @socket.read(count - data.bytesize)
+        return nil if chunk.nil? || chunk.empty?
+
+        data << chunk
+      end
+      data
+    rescue SystemCallError, IOError
+      nil
+    end
+  end
+end

data/lib/eui-ruby.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# The gem is `eui-ruby`; the library is `eui`.
+require_relative 'eui'

data/lib/eui.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'eui/version'
+require_relative 'eui/errors'
+require_relative 'eui/blake3'
+require_relative 'eui/theme'
+require_relative 'eui/proto'
+require_relative 'eui/view/style'
+require_relative 'eui/view/tree'
+require_relative 'eui/view/diff'
+require_relative 'eui/dsl'
+require_relative 'eui/assets'
+require_relative 'eui/manifest'
+require_relative 'eui/component'
+require_relative 'eui/websocket'
+require_relative 'eui/session'
+require_relative 'eui/server'
+require_relative 'eui/app'
+
+# EUI in Ruby: an application interface delivered over HTTPS without HTML,
+# CSS or JavaScript.
+#
+# The server sends an interface tree that is **already resolved**, in a
+# compact binary encoding; a native client applies it, lays it out and draws
+# it on the GPU. There is no tolerant parse, no cascade to resolve and no
+# script to run at the other end — which is why a view here is a hash and a
+# style is a flat, closed vocabulary rather than a language.
+#
+# The protocol is specified in `spec/` of the EUI repository; every file in
+# this gem names the section it implements.
+module EUI
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: eui-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Olivier Bonnaure
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  EUI delivers an application interface over HTTPS without HTML, CSS or
+  JavaScript: the server sends a tree that is already resolved, in a
+  compact binary encoding, and a native client lays it out and draws it on
+  the GPU. This gem is the server half in Ruby — the encoder, the session,
+  the content-addressed asset store, the signed manifest, and a component
+  model where a view is a hash and a handler changes state.
+email:
+- olivier@solisoft.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- examples/counter.rb
+- lib/eui-ruby.rb
+- lib/eui.rb
+- lib/eui/app.rb
+- lib/eui/assets.rb
+- lib/eui/blake3.rb
+- lib/eui/component.rb
+- lib/eui/dsl.rb
+- lib/eui/errors.rb
+- lib/eui/manifest.rb
+- lib/eui/proto.rb
+- lib/eui/proto/frame.rb
+- lib/eui/proto/limits.rb
+- lib/eui/proto/node.rb
+- lib/eui/proto/op.rb
+- lib/eui/proto/reader.rb
+- lib/eui/proto/style.rb
+- lib/eui/proto/writer.rb
+- lib/eui/server.rb
+- lib/eui/session.rb
+- lib/eui/theme.rb
+- lib/eui/version.rb
+- lib/eui/view/diff.rb
+- lib/eui/view/style.rb
+- lib/eui/view/tree.rb
+- lib/eui/websocket.rb
+homepage: https://github.com/solisoft/eui-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/solisoft/eui-ruby
+  changelog_uri: https://github.com/solisoft/eui-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/solisoft/eui/tree/main/spec
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'EUI applications in Ruby: the wire format, the views, and the server that
+  speaks them.'
+test_files: []