tarsier 0.1.0

data/lib/tarsier/websocket.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "digest"
+require "base64"
+
+module Tarsier
+  # WebSocket handler with room/channel abstraction
+  # Built on Fiber-based concurrency for efficient handling
+  class WebSocket
+    GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    OPCODES = { text: 0x1, binary: 0x2, close: 0x8, ping: 0x9, pong: 0xA }.freeze
+
+    class << self
+      # Define event handlers
+      def on(event, &block)
+        handlers[event] = block
+      end
+
+      # Get all handlers
+      def handlers
+        @handlers ||= {}
+      end
+
+      # Subscribe to a channel
+      def subscribe(channel)
+        channels[channel] ||= []
+      end
+
+      # Broadcast to a channel
+      def broadcast(channel, data)
+        channels[channel]&.each { |socket| socket.send_message(data) }
+      end
+
+      # Get all channels
+      def channels
+        @channels ||= {}
+      end
+    end
+
+    attr_reader :request, :params, :socket
+
+    def initialize(request, socket)
+      @request = request
+      @params = request.params
+      @socket = socket
+      @subscriptions = []
+      @open = false
+    end
+
+    # Perform WebSocket handshake
+    # @return [Boolean] true if handshake successful
+    def handshake!
+      key = @request.header("Sec-WebSocket-Key")
+      return false unless key
+
+      accept = Base64.strict_encode64(
+        Digest::SHA1.digest("#{key}#{GUID}")
+      )
+
+      response = [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Accept: #{accept}",
+        "",
+        ""
+      ].join("\r\n")
+
+      @socket.write(response)
+      @open = true
+      true
+    end
+
+    # Start the WebSocket connection loop
+    def run
+      return unless @open
+
+      trigger(:connect)
+
+      loop do
+        frame = read_frame
+        break unless frame
+
+        case frame[:opcode]
+        when OPCODES[:text], OPCODES[:binary]
+          trigger(:message, frame[:data])
+        when OPCODES[:ping]
+          send_frame(OPCODES[:pong], frame[:data])
+        when OPCODES[:close]
+          trigger(:close)
+          break
+        end
+      end
+    rescue IOError, Errno::ECONNRESET
+      trigger(:close)
+    ensure
+      cleanup
+    end
+
+    # Send a text message
+    # @param data [String] message data
+    def send_message(data)
+      send_frame(OPCODES[:text], data.to_s)
+    end
+
+    alias send send_message
+
+    # Send binary data
+    # @param data [String] binary data
+    def send_binary(data)
+      send_frame(OPCODES[:binary], data)
+    end
+
+    # Close the connection
+    # @param code [Integer] close code
+    # @param reason [String] close reason
+    def close(code: 1000, reason: "")
+      data = [code].pack("n") + reason
+      send_frame(OPCODES[:close], data)
+      @open = false
+    end
+
+    # Subscribe to a channel
+    # @param channel [String] channel name
+    def subscribe(channel)
+      self.class.channels[channel] ||= []
+      self.class.channels[channel] << self
+      @subscriptions << channel
+    end
+
+    # Unsubscribe from a channel
+    # @param channel [String] channel name
+    def unsubscribe(channel)
+      self.class.channels[channel]&.delete(self)
+      @subscriptions.delete(channel)
+    end
+
+    # Broadcast to a channel
+    # @param channel [String] channel name
+    # @param data [String] message data
+    def broadcast(channel, data)
+      self.class.broadcast(channel, data)
+    end
+
+    # Check if connection is open
+    # @return [Boolean]
+    def open?
+      @open
+    end
+
+    private
+
+    def trigger(event, *args)
+      handler = self.class.handlers[event]
+      instance_exec(*args, &handler) if handler
+    end
+
+    def read_frame
+      first_byte = @socket.read(1)&.unpack1("C")
+      return nil unless first_byte
+
+      second_byte = @socket.read(1)&.unpack1("C")
+      return nil unless second_byte
+
+      opcode = first_byte & 0x0F
+      masked = (second_byte & 0x80) != 0
+      length = second_byte & 0x7F
+
+      # Extended payload length
+      length = case length
+               when 126 then @socket.read(2).unpack1("n")
+               when 127 then @socket.read(8).unpack1("Q>")
+               else length
+               end
+
+      # Masking key (client frames are always masked)
+      mask = masked ? @socket.read(4).bytes : nil
+
+      # Payload
+      data = @socket.read(length)
+      data = unmask(data, mask) if mask
+
+      { opcode: opcode, data: data }
+    end
+
+    def send_frame(opcode, data)
+      frame = []
+
+      # First byte: FIN + opcode
+      frame << (0x80 | opcode)
+
+      # Length (server frames are not masked)
+      length = data.bytesize
+      if length < 126
+        frame << length
+      elsif length < 65_536
+        frame << 126
+        frame.concat([length].pack("n").bytes)
+      else
+        frame << 127
+        frame.concat([length].pack("Q>").bytes)
+      end
+
+      @socket.write(frame.pack("C*") + data)
+    end
+
+    def unmask(data, mask)
+      data.bytes.map.with_index { |byte, i| byte ^ mask[i % 4] }.pack("C*")
+    end
+
+    def cleanup
+      @subscriptions.each { |channel| unsubscribe(channel) }
+      @socket.close unless @socket.closed?
+    end
+  end
+
+  # Server-Sent Events (SSE) handler
+  class SSE
+    attr_reader :request, :response
+
+    def initialize(request, response)
+      @request = request
+      @response = response
+      @open = false
+    end
+
+    # Start SSE stream
+    def start
+      @response.status = 200
+      @response.set_header("Content-Type", "text/event-stream")
+      @response.set_header("Cache-Control", "no-cache")
+      @response.set_header("Connection", "keep-alive")
+      @response.set_header("X-Accel-Buffering", "no")
+      @open = true
+    end
+
+    # Send an event
+    # @param data [String] event data
+    # @param event [String, nil] event type
+    # @param id [String, nil] event ID
+    # @param retry_ms [Integer, nil] retry interval
+    def send(data, event: nil, id: nil, retry_ms: nil)
+      return unless @open
+
+      message = +""
+      message << "id: #{id}\n" if id
+      message << "event: #{event}\n" if event
+      message << "retry: #{retry_ms}\n" if retry_ms
+
+      data.to_s.each_line do |line|
+        message << "data: #{line.chomp}\n"
+      end
+      message << "\n"
+
+      @response.write(message)
+    end
+
+    # Send a comment (keep-alive)
+    # @param text [String] comment text
+    def comment(text)
+      @response.write(": #{text}\n\n") if @open
+    end
+
+    # Close the stream
+    def close
+      @open = false
+    end
+
+    # Check if stream is open
+    # @return [Boolean]
+    def open?
+      @open
+    end
+  end
+end

data/lib/tarsier.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative "tarsier/version"
+require_relative "tarsier/errors"
+require_relative "tarsier/router/node"
+require_relative "tarsier/router/route"
+require_relative "tarsier/router/compiler"
+require_relative "tarsier/router"
+require_relative "tarsier/request"
+require_relative "tarsier/response"
+require_relative "tarsier/params"
+require_relative "tarsier/controller"
+require_relative "tarsier/middleware/stack"
+require_relative "tarsier/middleware/base"
+require_relative "tarsier/middleware/logger"
+require_relative "tarsier/middleware/cors"
+require_relative "tarsier/middleware/csrf"
+require_relative "tarsier/middleware/rate_limit"
+require_relative "tarsier/middleware/compression"
+require_relative "tarsier/middleware/static"
+require_relative "tarsier/database"
+require_relative "tarsier/query"
+require_relative "tarsier/model"
+require_relative "tarsier/websocket"
+require_relative "tarsier/application"
+
+# Tarsier - A minimal, elegant Ruby web framework
+#
+# Tarsier provides a clean, expressive API for building web applications
+# with minimal boilerplate. Inspired by Flask, Sinatra, and Roda.
+#
+# @example Minimal application
+#   require 'tarsier'
+#
+#   app = Tarsier.app do
+#     get '/' do
+#       { message: 'Hello, World!' }
+#     end
+#   end
+#
+#   run app
+#
+# @example With database
+#   Tarsier.db :sqlite, 'app.db'
+#
+#   class User < Tarsier::Model
+#     attribute :name, :string
+#     attribute :email, :string
+#   end
+#
+# @author Tarsier Contributors
+# @since 0.1.0
+module Tarsier
+  class << self
+    # @return [Tarsier::Application] the current application instance
+    attr_accessor :current_app
+
+    # Create a new Tarsier application with minimal syntax
+    #
+    # @yield block for defining routes inline
+    # @return [Application] the application instance
+    #
+    # @example
+    #   app = Tarsier.app do
+    #     get('/') { { status: 'ok' } }
+    #   end
+    def app(&block)
+      @current_app = Application.new
+      @current_app.instance_eval(&block) if block_given?
+      @current_app.boot!
+      @current_app
+    end
+
+    # Create application with configuration block (Rails-style)
+    #
+    # @yield [Application] the application instance for configuration
+    # @return [Application]
+    #
+    # @example
+    #   Tarsier.application do
+    #     configure { self.secret_key = 'secret' }
+    #     routes do
+    #       root to: 'home#index'
+    #     end
+    #   end
+    def application(&block)
+      @current_app = Application.new
+      @current_app.instance_eval(&block) if block_given?
+      @current_app
+    end
+
+    # Configure database connection
+    #
+    # @param adapter [Symbol] database adapter (:sqlite, :postgres, :mysql)
+    # @param connection [String, Hash] connection string or options
+    # @return [Database::Connection]
+    #
+    # @example SQLite
+    #   Tarsier.db :sqlite, 'app.db'
+    #
+    # @example PostgreSQL
+    #   Tarsier.db :postgres, 'postgres://localhost/myapp'
+    #
+    # @example MySQL with options
+    #   Tarsier.db :mysql, host: 'localhost', database: 'myapp'
+    def db(adapter, connection = nil, **options)
+      Database.connect(adapter, connection, **options)
+    end
+
+    # Access the database connection
+    #
+    # @return [Database::Connection, nil]
+    def database
+      Database.connection
+    end
+
+    # Define routes for the application
+    #
+    # @yield [Router] the router instance
+    def routes(&block)
+      current_app&.routes(&block)
+    end
+
+    # Access the current router
+    #
+    # @return [Router, nil]
+    def router
+      current_app&.router
+    end
+
+    # Current environment
+    #
+    # @return [String]
+    def env
+      @env ||= ENV.fetch("TARSIER_ENV") { ENV.fetch("RACK_ENV", "development") }
+    end
+
+    # @return [Boolean] true if in development environment
+    def development?
+      env == "development"
+    end
+
+    # @return [Boolean] true if in production environment
+    def production?
+      env == "production"
+    end
+
+    # @return [Boolean] true if in test environment
+    def test?
+      env == "test"
+    end
+
+    # Framework root directory
+    #
+    # @return [String]
+    def root
+      @root ||= Dir.pwd
+    end
+
+    # Set framework root
+    #
+    # @param path [String]
+    def root=(path)
+      @root = File.expand_path(path)
+    end
+  end
+end