primate-run 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e3646fb9a37d9abb014fbe158eb36a657c9b2cc981eadc9f9f9688964ba6676
+  data.tar.gz: 41f42c7f73ff43165363faf5c1df9431d7e36faf0e2178ebb88dc864cc6d3758
+SHA512:
+  metadata.gz: 72bef66e9e5578b55874dea7f31408813e2c439240a60dd73e20421e1550743440065823d5bf41bd093a5bb5a333a11479a5cfe760ad80c986ae46d03b2dc687
+  data.tar.gz: 8c8084f98a4c0151b26506410c8ca4e60c2729e401f259ecf439381f00159d84d89e55efb2da381a3b68bab438e504118f0c8b64f0fe264ad4e13b25ea2c16bb

data/lib/primate/pema.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Pema
+  class ValidationError < StandardError; end
+
+  class Field
+    def parse(value, coerce = false)
+      raise NotImplementedError, 'Subclasses must implement parse'
+    end
+  end
+
+  class StringType < Field
+    def parse(value, coerce = false)
+      return value if value.is_a?(String)
+
+      if coerce
+        return value.to_s
+      end
+
+      raise ValidationError, "expected string, got #{value.class}"
+    end
+  end
+
+  class BooleanType < Field
+    def parse(value, coerce = false)
+      return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      if coerce
+        case value
+        when String
+          return false if value.empty?
+          case value.downcase
+          when 'true', '1', 'yes', 'on'
+            return true
+          when 'false', '0', 'no', 'off'
+            return false
+          else
+            raise ValidationError, "cannot parse '#{value}' as boolean"
+          end
+        else
+          raise ValidationError, "cannot coerce #{value.class} to boolean"
+        end
+      end
+
+      raise ValidationError, "expected boolean, got #{value.class}"
+    end
+  end
+
+  class IntType < Field
+    def parse(value, coerce = false)
+      return value if value.is_a?(Integer)
+
+      if coerce
+        case value
+        when Float
+          return value.to_i
+        when String
+          return 0 if value.empty?
+          return Integer(value)
+        else
+          raise ValidationError, "cannot coerce #{value.class} to int"
+        end
+      end
+
+      raise ValidationError, "expected integer, got #{value.class}"
+    rescue ArgumentError
+      raise ValidationError, "cannot parse '#{value}' as integer"
+    end
+  end
+
+  class FloatType < Field
+    def parse(value, coerce = false)
+      return value if value.is_a?(Float)
+
+      if coerce
+        case value
+        when Integer
+          return value.to_f
+        when String
+          return 0.0 if value.empty?
+          return Float(value)
+        else
+          raise ValidationError, "cannot coerce #{value.class} to float"
+        end
+      end
+
+      raise ValidationError, "expected float, got #{value.class}"
+    rescue ArgumentError
+      raise ValidationError, "cannot parse '#{value}' as float"
+    end
+  end
+
+  def self.string
+    StringType.new
+  end
+
+  def self.boolean
+    BooleanType.new
+  end
+
+  def self.int
+    IntType.new
+  end
+
+  def self.float
+    FloatType.new
+  end
+
+  class Schema
+    def initialize(fields)
+      @fields = fields
+    end
+
+    def parse(data, coerce = false)
+      result = {}
+
+      @fields.each do |name, field|
+        value = data.key?(name) ? data[name] : ''
+
+        begin
+          result[name] = field.parse(value, coerce)
+        rescue ValidationError => e
+          raise ValidationError, "parsing failed for field '#{name}': #{e.message}"
+        end
+      end
+
+      result
+    end
+  end
+
+  def self.schema(fields)
+    Schema.new(fields)
+  end
+end

data/lib/primate/readable.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Primate
+  class Readable
+    attr_reader :content_type
+
+    def initialize(typed_array, content_type = nil)
+      @ta = typed_array
+      @content_type = content_type
+      @pos = 0
+      @size = @ta[:length].to_i
+    end
+
+    def size = @size
+    def eof? = @pos >= @size
+    def rewind; @pos = 0; self; end
+
+    # return a binary string (ASCII-8BIT), advance position
+    def read(n = nil)
+      return ''.b if eof?
+      n = n ? [n, @size - @pos].min : (@size - @pos)
+      str = pack_range(@pos, n)
+      @pos += n
+      str
+    end
+
+    # return an array of bytes (integers), advance position
+    def bytes(n = nil)
+      return [] if eof?
+      n = n ? [n, @size - @pos].min : (@size - @pos)
+      arr = Array.new(n) { |i| @ta[@pos + i].to_i }
+      @pos += n
+      arr
+    end
+
+    # look ahead without advancing position (integers)
+    def peek(n)
+      n = [n, @size - @pos].min
+      Array.new(n) { |i| @ta[@pos + i].to_i }
+    end
+
+    # first n bytes from the beginning (integers), does not affect position
+    def head(n = 4)
+      n = [n, @size].min
+      Array.new(n) { |i| @ta[i].to_i }
+    end
+
+    # enumerate binary string chunks starting at current position (no rewind)
+    def each_chunk(chunk = 64 * 1024)
+      return enum_for(:each_chunk, chunk) unless block_given?
+      off = @pos
+      while off < @size
+        n = [chunk, @size - off].min
+        yield pack_range(off, n)
+        off += n
+      end
+      self
+    end
+
+    private
+
+    def pack_range(off, n)
+      Array.new(n) { |i| @ta[off + i].to_i }.pack('C*')
+    end
+  end
+end

data/lib/primate/request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'url'
+require_relative 'request_bag'
+require_relative 'request_body'
+
+class Request
+  attr_reader :url, :body, :path, :query, :headers, :cookies
+
+  # @param request [Object] JavaScript request object from the runtime
+  # @param helpers [Object] Helper functions from JavaScript runtime
+  def initialize(request, helpers)
+    @url = Primate::URL.new(request['url'])
+    @body = RequestBody.new(request['body'], helpers)
+    @path = RequestBag.new(request['path'], helpers)
+    @query = RequestBag.new(request['query'], helpers)
+    @headers = RequestBag.new(request['headers'], helpers)
+    @cookies = RequestBag.new(request['cookies'], helpers)
+  end
+end

data/lib/primate/request_bag.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'type'
+
+class RequestBag
+  # initialize with JavaScript object data
+  #
+  # @param data [Object] JavaScript object from runtime
+  def initialize(data, helpers)
+    @data = type(data, helpers)
+  end
+
+  # get a value by key
+  #
+  # @param key [String] The key to look up
+  # @return [String] The value as string
+  # @throws RuntimeError if key is missing
+  def get(key)
+    raise "RequestBag has no key #{key}" unless has?(key)
+    @data[key].to_s
+  end
+
+  # Get a value by key (alias for get, Ruby style)
+  def [](key)
+    get(key)
+  end
+
+  # Try to get a value by key
+  #
+  # @param key [String] The key to look up
+  # @return [String, nil] The value or nil if absent
+  def try(key)
+    has?(key) ? @data[key].to_s : nil
+  end
+
+  # Whether the bag contains a defined value for the key
+  #
+  # @param key [String] The key to check
+  # @return [Boolean] True if key exists with defined value
+  def has?(key)
+    @data.key?(key) && !@data[key].nil?
+  end
+
+  # Parse the entire bag with a schema
+  #
+  # @param schema [Object] Object with parse method
+  # @param coerce [Boolean] Whether to coerce types
+  # @return [Object] Parsed result
+  def parse(schema, coerce = false)
+    schema.parse(@data, coerce)
+  end
+
+  # Convert to hash (Ruby standard conversion)
+  #
+  # @return [Hash] The underlying data
+  def to_h
+    @data
+  end
+
+  # Size of the bag
+  #
+  # @return [Integer] Number of entries
+  def size
+    @data.size
+  end
+end

data/lib/primate/request_body.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'readable'
+require_relative 'uploaded_file'
+
+# Wrapper for request body with type-specific methods
+class RequestBody
+  # Initialize with JavaScript body object
+  #
+  # @param body [Object] JavaScript body object from runtime
+  # @param helpers [Object] Helper functions from JavaScript runtime
+  def initialize(body, helpers)
+    @body = body
+    @helpers = helpers
+  end
+
+  # Get body as JSON (parsed hash)
+  #
+  # @return [Hash] Parsed JSON data
+  def json
+    JSON.parse(@body.json.to_s)
+  end
+
+  # Get body as plain text
+  #
+  # @return [String] Body as string
+  def text
+    @body.text.to_s
+  end
+
+  # Get form fields as hash
+  #
+  # @return [Hash] Form field data
+  def fields
+    JSON.parse(@body.fields.to_s)
+  end
+
+  def files
+    files = @body.files
+
+    Array.new(files[:length].to_i) do |i|
+      f = files[i]
+      Primate::UploadedFile.new(
+        field: f['field'].to_s,
+        name:  f['name'].to_s,
+        type:  f['type'].to_s,
+        size:  f['size'].to_i,
+        bytes: f['bytes']
+      )
+    end
+  end
+
+  def binary
+    binary = @body.binary
+    Primate::Readable.new(binary['buffer'], binary['mime'].to_s)
+  end
+end

data/lib/primate/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Response
+  # Create a view response
+  #
+  # @param name [String] The view template name
+  # @param props [Hash] Props to pass to the view
+  # @param options [Hash] Additional view options
+  # @return [Hash] Response object for the Primate framework
+  def self.view(name, props = {}, options = {})
+    { __PRMT__: 'view', name: name, props: props, options: options }
+  end
+
+  # Create a redirect response
+  #
+  # @param location [String] URL to redirect to
+  # @param options [Hash] Redirect options (status code, etc.)
+  # @return [Hash] Response object for the Primate framework
+  def self.redirect(location, options = {})
+    { __PRMT__: 'redirect', location: location, options: options }
+  end
+
+  # Create an error response
+  #
+  # @param options [Hash] Error options
+  # @return [Hash] Response object for the Primate framework
+  def self.error(options = {})
+    { __PRMT__: 'error', options: options }
+  end
+end

data/lib/primate/route.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative 'request'
+require_relative 'response'
+require_relative '../primate'
+
+# Route registration and handling
+module Route
+  @routes = {}
+
+  # Register a GET route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.get(&block)
+    @routes['GET'] = block
+  end
+
+  # Register a POST route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.post(&block)
+    @routes['POST'] = block
+  end
+
+  # Register a PUT route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.put(&block)
+    @routes['PUT'] = block
+  end
+
+  # Register a PATCH route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.patch(&block)
+    @routes['PATCH'] = block
+  end
+
+  # Register a DELETE route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.delete(&block)
+    @routes['DELETE'] = block
+  end
+
+  # Register a HEAD route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.head(&block)
+    @routes['HEAD'] = block
+  end
+
+  # Register a OPTIONS route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.options(&block)
+    @routes['OPTIONS'] = block
+  end
+
+  # Register a CONNECT route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.connect(&block)
+    @routes['CONNECT'] = block
+  end
+
+  # Register a TRACE route handler
+  #
+  # @yieldparam request [Request] The HTTP request object
+  # @return [void]
+  def self.trace(&block)
+    @routes['TRACE'] = block
+  end
+
+  # Get all registered routes
+  #
+  # @return [Hash] Hash of HTTP method => handler block
+  def self.routes
+    @routes
+  end
+
+  def self.set_session(session, helpers)
+    PrimateInternal.set_session(session, helpers)
+  end
+  # Execute a route handler for the given HTTP method
+  #
+  # @param method [String] HTTP method
+  # @param request [Request] Request object
+  # @return [Object] Response from the route handler
+  def self.call_route(method, request)
+    handler = @routes[method.upcase]
+    return Response.error(status: 404) unless handler
+
+    handler.call(request)
+  end
+end

data/lib/primate/session.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Session management helpers
+module Session
+  class << self
+    attr_accessor :current
+
+    # Set the current session instance (called by framework)
+    #
+    # @param session_instance [SessionInstance] Session instance from JavaScript runtime
+    # @return [void]
+    def set_current(session_instance)
+      self.current = session_instance
+    end
+
+    # Get the session ID
+    #
+    # @return [String] Session identifier
+    def id
+      current&.id
+    end
+
+    # Check if session exists
+    #
+    # @return [Boolean] True if session exists
+    def exists?
+      current&.exists || false
+    end
+
+    # Create a new session with data
+    #
+    # @param data [Hash] Initial session data
+    # @return [void]
+    def create(data)
+      current&.create(data)
+    end
+
+    # Get session data (raises if no session)
+    #
+    # @return [Hash] Session data
+    def get
+      current&.get || {}
+    end
+
+    # Try to get session data (returns empty if no session)
+    #
+    # @return [Hash] Session data or empty hash
+    def try
+      current&.try || {}
+    end
+
+    # Set session data
+    #
+    # @param data [Hash] Data to store in session
+    # @return [void]
+    def set(data)
+      current&.set(data)
+    end
+
+    # Destroy the session
+    #
+    # @return [void]
+    def destroy
+      current&.destroy
+    end
+  end
+end
+
+# Internal session instance class (used by framework)
+class SessionInstance
+  # Initialize session with JavaScript session object and helpers
+  #
+  # @param session [Object] JavaScript session object from the runtime
+  # @param helpers [Object] Helper functions from JavaScript runtime
+  def initialize(session, helpers)
+    @session = session
+    @helpers = helpers
+  end
+
+  # Get the session ID
+  #
+  # @return [String] Session identifier
+  def id
+    @session['id']
+  end
+
+  # Check if session exists
+  #
+  # @return [Boolean] True if session exists
+  def exists
+    @session['exists']
+  end
+
+  # Create a new session with data
+  #
+  # @param data [Hash] Initial session data
+  # @return [void]
+  def create(data)
+    @session.create(data)
+  end
+
+  # Get session data (raises if no session)
+  #
+  # @return [Hash] Session data
+  def get
+    @session.get
+  end
+
+  # Try to get session data (returns empty if no session)
+  #
+  # @return [Hash] Session data or empty hash
+  def try
+    @session.try
+  end
+
+  # Set session data
+  #
+  # @param data [Hash] Data to store in session
+  # @return [void]
+  def set(data)
+    @session.set(data)
+  end
+
+  # Destroy the session
+  #
+  # @return [void]
+  def destroy
+    @session.destroy
+  end
+end

data/lib/primate/type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+
+def type(value, helpers)
+  type = helpers.type(value).to_s
+
+  if type == 'integer'
+    return value.to_i
+  end
+
+  if type == 'float'
+    return value.to_f
+  end
+
+  if type == 'boolean'
+    return value == JS::True
+  end
+
+  if type == 'string'
+    return value.to_s
+  end
+
+  if type == 'nil'
+    return nil
+  end
+
+  if type == 'array'
+    as_array = JS.global[:Array].from(value)
+    return Array.new(as_array[:length].to_i) {
+      type(as_array[_1], helpers)
+    }
+  end
+
+  if type == 'object'
+    as_entries = JS.global[:Object].entries(value)
+    return Hash[Array.new(as_entries[:length].to_i) {[
+      as_entries[_1][0].to_s,
+      type(as_entries[_1][1], helpers)
+    ]}]
+  end
+
+  value
+end

data/lib/primate/uploaded_file.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'readable'
+
+module Primate
+  class UploadedFile
+    attr_reader :field, :filename, :content_type, :size
+
+    def initialize(field:, name:, type:, size:, bytes:)
+      @field = field
+      @filename = name
+      @content_type = type
+      @size = size
+      @io = Primate::Readable.new(bytes, type)
+    end
+
+    def io = @io
+  end
+end

data/lib/primate/url.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Primate
+  class URL
+    attr_reader :href, :origin, :protocol, :username, :password, :host,
+                :hostname, :port, :pathname, :search, :hash
+
+    # initialize URL from JavaScript URL object
+    # @param url [Object] JavaScript URL object from the runtime
+    def initialize(url)
+      @href = url['href'].to_s
+      @origin = url['origin'].to_s
+      @protocol = url['protocol'].to_s
+      @username = url['username'].to_s
+      @password = url['password'].to_s
+      @host = url['host'].to_s
+      @hostname = url['hostname'].to_s
+      @port = url['port'].to_s
+      @pathname = url['pathname'].to_s
+      @search = url['search'].to_s
+      @hash = url['hash'].to_s
+    end
+  end
+end

data/lib/primate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Primate
+  VERSION = '0.1.0'
+end

data/lib/primate.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "primate/version"
+
+module PrimateInternal
+  def self.set_session(session, helpers)
+    require_relative "primate/session"
+    session_instance = SessionInstance.new(session, helpers)
+    Session.set_current(session_instance)
+  end
+end

data/sig/primate.rbs

@@ -0,0 +1,162 @@
+# RBS type signatures for Primate Ruby gem
+
+module Primate
+  VERSION: String
+
+  class URL
+    attr_reader href: String
+    attr_reader origin: String
+    attr_reader protocol: String
+    attr_reader username: String
+    attr_reader password: String
+    attr_reader host: String
+    attr_reader hostname: String
+    attr_reader port: String
+    attr_reader pathname: String
+    attr_reader search: String
+    attr_reader hash: String
+
+    def initialize: (untyped url) -> void
+  end
+
+  class Readable
+    attr_reader content_type: String?
+
+    def initialize: (untyped typed_array, String? content_type) -> void
+    def size: () -> Integer
+    def eof?: () -> bool
+    def rewind: () -> self
+    def read: (?Integer? n) -> String
+    def bytes: (?Integer? n) -> Array[Integer]
+    def peek: (Integer n) -> Array[Integer]
+    def head: (?Integer n) -> Array[Integer]
+    def each_chunk: (?Integer chunk) { (String) -> void } -> self
+                  | (?Integer chunk) -> Enumerator[String, self]
+  end
+
+  class UploadedFile
+    attr_reader field: String
+    attr_reader filename: String
+    attr_reader content_type: String
+    attr_reader size: Integer
+
+    def initialize: (field: String, name: String, type: String, size: Integer, bytes: untyped) -> void
+    def io: () -> Readable
+  end
+end
+
+class RequestBody
+  def initialize: (untyped body, untyped helpers) -> void
+  def json: () -> Hash[String, untyped]
+  def text: () -> String
+  def fields: () -> Hash[String, untyped]
+  def files: () -> Array[Primate::UploadedFile]
+  def binary: () -> Primate::Readable
+end
+
+class RequestBag
+  def initialize: (untyped data, untyped helpers) -> void
+  def get: (String key) -> String
+  def []: (String key) -> String
+  def try: (String key) -> String?
+  def has?: (String key) -> bool
+  def parse: (untyped schema, ?bool coerce) -> untyped
+  def to_h: () -> Hash[String, untyped]
+  def size: () -> Integer
+end
+
+class Request
+  attr_reader url: Primate::URL
+  attr_reader body: RequestBody
+  attr_reader path: RequestBag
+  attr_reader query: RequestBag
+  attr_reader headers: RequestBag
+  attr_reader cookies: RequestBag
+
+  def initialize: (untyped request, untyped helpers) -> void
+end
+
+class SessionInstance
+  def initialize: (untyped session, untyped helpers) -> void
+  def id: () -> String
+  def exists: () -> bool
+  def create: (Hash[String, untyped] data) -> void
+  def get: () -> Hash[String, untyped]
+  def try: () -> Hash[String, untyped]
+  def set: (Hash[String, untyped] data) -> void
+  def destroy: () -> void
+end
+
+module Session
+  def self.set_current: (SessionInstance session_instance) -> void
+  def self.id: () -> String?
+  def self.exists?: () -> bool
+  def self.create: (Hash[String, untyped] data) -> void
+  def self.get: () -> Hash[String, untyped]
+  def self.try: () -> Hash[String, untyped]
+  def self.set: (Hash[String, untyped] data) -> void
+  def self.destroy: () -> void
+end
+
+module Response
+  def self.view: (String name, ?Hash[String, untyped] props, ?Hash[String, untyped] options) -> Hash[Symbol, untyped]
+  def self.redirect: (String location, ?Hash[String, untyped] options) -> Hash[Symbol, untyped]
+  def self.error: (?Hash[String, untyped] options) -> Hash[Symbol, untyped]
+end
+
+module Route
+  def self.get: () { (Request) -> untyped } -> void
+  def self.post: () { (Request) -> untyped } -> void
+  def self.put: () { (Request) -> untyped } -> void
+  def self.patch: () { (Request) -> untyped } -> void
+  def self.delete: () { (Request) -> untyped } -> void
+  def self.head: () { (Request) -> untyped } -> void
+  def self.options: () { (Request) -> untyped } -> void
+  def self.connect: () { (Request) -> untyped } -> void
+  def self.trace: () { (Request) -> untyped } -> void
+  def self.routes: () -> Hash[String, Proc]
+  def self.set_session: (untyped session, untyped helpers) -> void
+  def self.call_route: (String method, Request request) -> untyped
+end
+
+module Pema
+  class ValidationError < StandardError
+  end
+
+  class Field
+    def parse: (untyped value, ?bool coerce) -> untyped
+  end
+
+  class StringType < Field
+    def parse: (untyped value, ?bool coerce) -> String
+  end
+
+  class BooleanType < Field
+    def parse: (untyped value, ?bool coerce) -> bool
+  end
+
+  class IntType < Field
+    def parse: (untyped value, ?bool coerce) -> Integer
+  end
+
+  class FloatType < Field
+    def parse: (untyped value, ?bool coerce) -> Float
+  end
+
+  class Schema
+    def initialize: (Hash[String, Field] fields) -> void
+    def parse: (Hash[String, untyped] data, ?bool coerce) -> Hash[String, untyped]
+  end
+
+  def self.string: () -> StringType
+  def self.boolean: () -> BooleanType
+  def self.int: () -> IntType
+  def self.float: () -> FloatType
+  def self.schema: (Hash[String, Field] fields) -> Schema
+end
+
+module PrimateInternal
+  def self.set_session: (untyped session, untyped helpers) -> void
+end
+
+def type: (untyped value, untyped helpers) -> untyped

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: primate-run
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Primate Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.26'
+description: Provides Ruby support for building web applications with the Primate
+  framework
+email:
+- terrablue@proton.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/primate.rb
+- lib/primate/pema.rb
+- lib/primate/readable.rb
+- lib/primate/request.rb
+- lib/primate/request_bag.rb
+- lib/primate/request_body.rb
+- lib/primate/response.rb
+- lib/primate/route.rb
+- lib/primate/session.rb
+- lib/primate/type.rb
+- lib/primate/uploaded_file.rb
+- lib/primate/url.rb
+- lib/primate/version.rb
+- sig/primate.rbs
+homepage: https://primate.run
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://primate.run
+  source_code_uri: https://github.com/primate-run/ruby
+  bug_tracker_uri: https://github.com/primate-run/ruby/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby route handlers for the Primate web framework
+test_files: []