takagi 0.1.0 → 1.1.0

data/sig/takagi/router.rbs

@@ -0,0 +1,166 @@
+module Takagi
+  class Router
+    @routes: untyped
+
+    @routes_mutex: untyped
+
+    @logger: untyped
+
+    @route_matcher: untyped
+
+    @metadata_extractor: untyped
+
+    DEFAULT_CONTENT_FORMAT: 50
+
+    # Global singleton instance for backward compatibility
+    def self.instance: () -> Router
+
+    # Reset the global instance (for testing)
+    def self.reset!: () -> void
+
+    # Represents a registered route with its handler and CoRE Link Format metadata
+    class RouteEntry
+      @method: untyped
+
+      @path: untyped
+
+      @block: untyped
+
+      @receiver: untyped
+
+      @attribute_set: untyped
+
+      attr_reader method: untyped
+
+      attr_reader path: untyped
+
+      attr_reader block: untyped
+
+      attr_reader receiver: untyped
+
+      attr_reader attribute_set: untyped
+
+      def initialize: (method: untyped, path: untyped, block: untyped, ?metadata: ::Hash[untyped, untyped], ?receiver: untyped?) -> void
+
+      # Returns the underlying metadata hash for backward compatibility
+      def metadata: () -> untyped
+
+      # Configure CoRE Link Format attributes using DSL block
+      #
+      # @example
+      #   entry.configure_attributes do
+      #     rt 'sensor'
+      #     obs true
+      #     ct 'application/json'
+      #   end
+      def configure_attributes: () { (?) -> untyped } -> untyped
+
+      # Support for dup operation (used in discovery)
+      def initialize_copy: (untyped original) -> untyped
+    end
+
+    # Provides the execution context for route handlers, exposing helper
+    # methods for configuring CoRE Link Format attributes via a small DSL.
+    class RouteContext
+      @entry: untyped
+
+      @request: untyped
+
+      @params: untyped
+
+      @receiver: untyped
+
+      # Create a fresh AttributeSet for this request to avoid cross-request state sharing
+      # Initialize it with a copy of the entry's current metadata
+      @core_attributes: untyped
+
+      extend Forwardable
+
+      include Takagi::Helpers
+
+      attr_reader request: untyped
+
+      attr_reader params: untyped
+
+      # Aliases for common methods
+      alias content_format ct
+
+      alias observable obs
+
+      alias if_ interface
+
+      def initialize: (untyped entry, untyped request, untyped params, untyped receiver) -> void
+
+      def run: (untyped block) -> untyped
+
+      private
+
+      # Delegates method calls to the receiver (application instance)
+      # This allows route handlers to call application methods within their blocks
+      # Example: get '/users' do; fetch_users; end - calls application's fetch_users method
+      def method_missing: (untyped name, *untyped) ?{ (?) -> untyped } -> untyped
+
+      # Required pair for method_missing to properly support respond_to?
+      def respond_to_missing?: (untyped name, ?bool include_private) -> untyped
+    end
+
+    def initialize: () -> void
+
+    # Registers a new route for a given HTTP method and path
+    # @param method [String] The HTTP method (GET, POST, etc.)
+    # @param path [String] The URL path, can include dynamic segments like `:id`
+    # @param block [Proc] The handler to be executed when the route is matched
+    def add_route: (untyped method, untyped path, ?metadata: ::Hash[untyped, untyped]) { (?) -> untyped } -> untyped
+
+    # Registers a OBSERVE route
+    # @param path [String] The URL path
+    # @param block [Proc] The handler function
+    def observable: (untyped path, ?metadata: ::Hash[untyped, untyped]) { (?) -> untyped } -> untyped
+
+    def all_routes: () -> untyped
+
+    def find_observable: (untyped path) -> untyped
+
+    # Finds a registered route for a given method and path
+    # @param method [String] HTTP method
+    # @param path [String] URL path
+    # @return [Proc, Hash] The matching handler and extracted parameters
+    def find_route: (untyped method, untyped path) -> untyped
+
+    def link_format_entries: () -> untyped
+
+    # Applies CoRE metadata outside the request cycle. Useful for boot time
+    # configuration where the DSL block does not have a live request object.
+    def configure_core: (untyped method, untyped path) ?{ (?) -> untyped } -> (nil | untyped)
+
+    private
+
+    def wrap_block: (untyped entry) -> (nil | untyped)
+
+    # Matches dynamic routes that contain parameters (e.g., `/users/:id`)
+    # Delegates to RouteMatcher for the actual matching logic
+    # @param method [String] HTTP method
+    # @param path [String] Request path
+    # @return [Array(RouteEntry, Hash)] Matched route entry and extracted parameters
+    def match_dynamic_route: (untyped method, untyped path) -> untyped
+
+    def build_route_entry: (untyped method, untyped path, untyped metadata, untyped block) -> untyped
+
+    # Normalizes route metadata with sensible defaults for CoRE Link Format
+    #
+    # @param method [String] HTTP-like method (GET, POST, OBSERVE, etc.)
+    # @param path [String] Route path
+    # @param metadata [Hash, nil] User-provided metadata
+    # @return [Hash] Normalized metadata with defaults applied
+    def normalize_metadata: (untyped method, untyped path, untyped metadata) -> untyped
+
+    def default_resource_type: (untyped method) -> ("core#observable" | "core#endpoint")
+
+    def default_interface: (untyped method) -> ("takagi.observe" | ::String)
+
+    # Executes route handler in metadata extraction mode to capture core block attributes
+    # Delegates to MetadataExtractor for the actual extraction logic
+    # @param entry [RouteEntry] The route entry to extract metadata from
+    def extract_metadata_from_handler: (untyped entry) -> untyped
+  end
+end

data/sig/takagi/serialization.rbs

@@ -0,0 +1,32 @@
+# Takagi::Serialization - Content-format serialization system
+module Takagi
+  module Serialization
+    # Custom error classes
+    class Error < StandardError
+    end
+
+    class UnknownFormatError < Error
+    end
+
+    class EncodeError < Error
+    end
+
+    class DecodeError < Error
+    end
+
+    class InvalidSerializerError < Error
+    end
+
+    # Register default serializers
+    def self.register_defaults!: () -> void
+
+    # Encode data with format
+    def self.encode: (untyped data, Integer format) -> String
+
+    # Decode bytes with format
+    def self.decode: (String bytes, Integer format) -> untyped
+
+    # Check if format is supported
+    def self.supports?: (Integer format) -> bool
+  end
+end

data/sig/takagi/server/multi.rbs

@@ -0,0 +1,16 @@
+module Takagi
+  module Server
+    # Helper class to run multiple servers concurrently
+    class Multi
+      @servers: untyped
+
+      @threads: untyped
+
+      def initialize: (untyped servers) -> void
+
+      def run!: () -> untyped
+
+      def shutdown!: () -> untyped
+    end
+  end
+end

data/sig/takagi/server/tcp.rbs

@@ -0,0 +1,42 @@
+module Takagi
+  module Server
+    # TCP server implementation for CoAP over TCP
+    class Tcp
+      @port: untyped
+
+      @worker_threads: untyped
+
+      @middleware_stack: untyped
+
+      @router: untyped
+
+      @logger: untyped
+
+      @watcher: untyped
+
+      @server: untyped
+
+      @sender: untyped
+
+      @workers: untyped
+
+      @shutdown_called: untyped
+
+      def initialize: (?port: ::Integer, ?worker_threads: ::Integer, ?middleware_stack: untyped?, ?router: untyped?, ?logger: untyped?, ?watcher: untyped?, ?sender: untyped?) -> void
+
+      def run!: () -> untyped
+
+      def shutdown!: () -> (nil | untyped)
+
+      private
+
+      def handle_connection: (untyped sock) -> untyped
+
+      def read_request: (untyped sock) -> (nil | untyped)
+
+      def build_response: (untyped inbound_request) -> untyped
+
+      def transmit_response: (untyped sock, untyped response) -> untyped
+    end
+  end
+end

data/sig/takagi/server/udp.rbs

@@ -0,0 +1,52 @@
+module Takagi
+  module Server
+    # UDP server for handling CoAP messages
+    class Udp
+      @port: untyped
+
+      @worker_processes: untyped
+
+      @worker_threads: untyped
+
+      @middleware_stack: untyped
+
+      @router: untyped
+
+      @logger: untyped
+
+      @watcher: untyped
+
+      @socket: untyped
+
+      @sender: untyped
+
+      @shutdown_called: untyped
+
+      @worker_pids: untyped
+
+      def initialize: (?port: ::Integer, ?worker_processes: ::Integer, ?worker_threads: ::Integer, ?middleware_stack: untyped?, ?router: untyped?, ?logger: untyped?, ?watcher: untyped?) -> void
+
+      # Starts the server with multiple worker processes
+      def run!: () -> untyped
+
+      # Gracefully shuts down all workers
+      def shutdown!: () -> (nil | untyped)
+
+      private
+
+      def log_boot_details: () -> untyped
+
+      def spawn_workers: () -> untyped
+
+      def fork_worker: () -> untyped
+
+      def worker_configuration: () -> { port: untyped, socket: untyped, middleware_stack: untyped, sender: untyped, logger: untyped, threads: untyped }
+
+      def close_socket: () -> untyped
+
+      def terminate_workers: () -> (nil | untyped)
+
+      def test_environment?: () -> untyped
+    end
+  end
+end

data/sig/takagi/server/udp_worker.rbs

@@ -0,0 +1,42 @@
+module Takagi
+  module Server
+    # Handles incoming UDP messages on behalf of the master Udp server.
+    class UdpWorker
+      @socket: untyped
+
+      @middleware_stack: untyped
+
+      @sender: untyped
+
+      @logger: untyped
+
+      @port: untyped
+
+      @threads: untyped
+
+      @dedup_cache: untyped
+
+      def initialize: (socket: untyped, middleware_stack: untyped, **untyped options) -> void
+
+      def run: () -> untyped
+
+      private
+
+      def process_loop: (untyped queue) -> untyped
+
+      def spawn_thread: (untyped queue) -> untyped
+
+      def handle_request: (untyped request, untyped addr) -> untyped
+
+      def log_inbound_request: (untyped inbound_request) -> untyped
+
+      def immediate_response: (untyped inbound_request) -> (untyped | nil)
+
+      def log_middleware_result: (untyped result) -> (nil | untyped)
+
+      def build_response: (untyped inbound_request, untyped result) -> untyped
+
+      def transmit: (untyped response, untyped addr) -> untyped
+    end
+  end
+end

data/sig/takagi/server.rbs

@@ -0,0 +1,4 @@
+module Takagi
+  module Server
+  end
+end

data/sig/takagi/server_registry.rbs

@@ -0,0 +1,71 @@
+module Takagi
+  # Registry for CoAP server implementations
+  #
+  # Allows registering different protocol implementations (UDP, TCP, DTLS, QUIC, etc.)
+  # without modifying core code. Follows the Open/Closed Principle.
+  #
+  # @example Registering a server
+  #   ServerRegistry.register(:udp, Server::Udp)
+  #   ServerRegistry.register(:tcp, Server::Tcp)
+  #
+  # @example Building a server
+  #   server = ServerRegistry.build(:tcp, port: 5683, worker_threads: 4)
+  #
+  # @example Adding a custom protocol
+  #   class MyCustomServer
+  #     def initialize(port:, **options)
+  #       # ...
+  #     end
+  #   end
+  #   ServerRegistry.register(:custom, MyCustomServer)
+  class ServerRegistry
+    self.@servers: untyped
+
+    self.@mutex: untyped
+
+    class ProtocolNotFoundError < StandardError
+    end
+
+    # Register a server implementation for a protocol
+    #
+    # @param protocol [Symbol] Protocol identifier (:udp, :tcp, :dtls, etc.)
+    # @param klass [Class] Server class that responds to .new
+    # @param options [Hash] Optional metadata (description, rfc, etc.)
+    #
+    # @example
+    #   ServerRegistry.register(:udp, Server::Udp, rfc: 'RFC 7252')
+    #   ServerRegistry.register(:tcp, Server::Tcp, rfc: 'RFC 8323')
+    def self.register: (untyped protocol, untyped klass, **untyped options) -> untyped
+
+    # Build a server instance for the given protocol
+    #
+    # @param protocol [Symbol] Protocol identifier
+    # @param options [Hash] Options to pass to server constructor
+    # @return [Object] Server instance
+    # @raise [ProtocolNotFoundError] If protocol is not registered
+    #
+    # @example
+    #   server = ServerRegistry.build(:tcp, port: 5683, worker_threads: 4)
+    def self.build: (untyped protocol, **untyped options) -> untyped
+
+    # Check if a protocol is registered
+    #
+    # @param protocol [Symbol] Protocol identifier
+    # @return [Boolean] true if registered
+    def self.registered?: (untyped protocol) -> untyped
+
+    # Get all registered protocols
+    #
+    # @return [Array<Symbol>] List of protocol identifiers
+    def self.protocols: () -> untyped
+
+    # Get metadata for a protocol
+    #
+    # @param protocol [Symbol] Protocol identifier
+    # @return [Hash, nil] Metadata hash or nil if not found
+    def self.metadata_for: (untyped protocol) -> untyped
+
+    # Clear all registrations (useful for testing)
+    def self.clear!: () -> untyped
+  end
+end

data/sig/takagi/tcp_client.rbs

@@ -0,0 +1,23 @@
+module Takagi
+  # CoAP-over-TCP client for testing Takagi servers with TCP transport.
+  #
+  # This client implements CoAP over TCP (RFC 8323) with automatic length framing.
+  # Unlike the UDP client, TCP provides reliable delivery so no retransmission
+  # manager is needed.
+  #
+  # @example Basic usage with auto-close (recommended)
+  #   Takagi::TcpClient.open('coap+tcp://localhost:5683') do |client|
+  #     client.get('/temperature')
+  #   end
+  #
+  # @example Manual lifecycle management
+  #   client = Takagi::TcpClient.new('coap+tcp://localhost:5683')
+  #   begin
+  #     client.get('/temperature')
+  #   ensure
+  #     client.close
+  #   end
+  class TcpClient < ClientBase
+    def request: (untyped method, untyped path, ?untyped? payload) { (?) -> untyped } -> untyped
+  end
+end

data/sig/takagi/version.rbs

@@ -0,0 +1,5 @@
+module Takagi
+  VERSION: "1.0.0"
+
+  NAME: "It works on my machine"
+end

data/takagi.gemspec

@@ -1,44 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "lib/takagi/version"
+require_relative 'lib/takagi/version'
+
+# Compute files at the top level so the Gem::Specification block can
+# reference it (the block runs in instance context, not top-level, so
+# a top-level `def gem_files` is not visible inside `spec.files =`).
+FILES = Dir.chdir(__dir__) do
+  `git ls-files -z`.split("\x0").reject do |file|
+    (File.expand_path(file) == __FILE__) ||
+      file.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+  end
+end
+
+HOMEPAGE = 'https://github.com/takagi-works/takagi'
 
 Gem::Specification.new do |spec|
-  spec.name = "takagi"
+  spec.name = 'takagi'
   spec.version = Takagi::VERSION
-  spec.authors = ["Dominik Matoulek"]
-  spec.email = ["domitea@gmail.com"]
-
-  spec.summary = "Lightweight CoAP framework for Ruby"
-  spec.description = "Sinatra-like framework for CoAP and IoT messaging."
-  spec.homepage = "https://github.com/domitea/takagi"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
-
-  spec.metadata["allowed_push_host"] ||= "https://rubygems.org"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/domitea/takagi"
-  spec.metadata["changelog_uri"] = "https://github.com/domitea/takagi/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.authors = ['Dominik Matoulek']
+  spec.email = ['domitea@gmail.com']
+
+  spec.summary = 'Lightweight CoAP framework for Ruby'
+  spec.description = 'Sinatra-like framework for CoAP and IoT messaging.'
+  spec.homepage = HOMEPAGE
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['allowed_push_host'] ||= 'https://rubygems.org'
+
+  spec.metadata['homepage_uri']    = HOMEPAGE
+  spec.metadata['source_code_uri'] = "#{HOMEPAGE}.git"
+  spec.metadata['changelog_uri']   = "#{HOMEPAGE}/blob/master/CHANGELOG.md"
+
+  spec.files = FILES
+  spec.bindir = 'bin'
+  spec.executables = ['takagi-dev']
+  spec.require_paths = ['lib']
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-  spec.add_dependency "rack"
-  spec.add_dependency "sequel"
+  spec.add_dependency 'rack', '~> 2.0'
+  spec.add_dependency 'zeitwerk', '~> 2.0'
 
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'rspec', '~> 3.0'
 
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end