HTTPRuby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd11c3b0f3a918f0a03b5598ce7f4dd6c2e4dfe6c17c8a400bddd2730898248b
+  data.tar.gz: 93ecdbcd668d9c1122f53246654e04251bb3cc9bfe7258b4602b04510befa47c
+SHA512:
+  metadata.gz: b387fdf611455d8823831e82bbbb765b43f0e1d299e4a1f3b1cc1a7c4bb385d62a6c15eec4ca70d44bbf55c539371f09ebd93216e789a8faceaad2c4e5eeef05
+  data.tar.gz: 2daf5df235ad5ea20156f83a1e0f267107c724534e2010c93be16e2f11ab81486d95ed9cdb0e5bd59d3c7b3e0094c33180e855a6f05b51bd9c4a79a09058d4aa

data/README.md

@@ -0,0 +1,100 @@
+# Own HTTP Server Framework
+
+This project is a lightweight and customizable HTTP server framework built in Ruby, designed to work seamlessly with Puma. It provides robust tools for creating and managing web APIs, offering features such as route handling, dynamic parameters, query validation, typed responses, and JSON body parsing, all while processing requests asynchronously.
+
+## Purpose
+
+The goal of this project is to build an HTTP server framework similar to FastAPI but for Ruby, enabling developers to create web applications quickly and effectively.
+
+## Technologies and Libraries
+
+- **Ruby**: Core programming language for the framework.
+- **Puma**: High-performance web server used to handle requests.
+- **Rack**: Interface between web servers and web applications.
+- **JSON**: Parsing and generating JSON responses.
+
+## Implementation Overview
+
+This framework consists of the following main components:
+
+### `App`
+The main class responsible for managing routers and handling requests asynchronously.
+
+#### Key Features:
+- Adds routers to the application.
+- Handles incoming requests and delegates them to appropriate routers.
+- Parses JSON bodies and query parameters.
+- Generates JSON responses.
+- Asynchronous request handling.
+
+```ruby
+class Router
+   def initialize
+      @routes = { GET: {}, POST: {}, PUT: {}, DELETE: {} }
+   end
+
+   def add_route(method, path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+      @routes[method][path] = {
+              accepted_queries: accepted_queries,
+              accepted_body: accepted_body,
+              accepted_response: accepted_response,
+              handler: block
+      }
+   end
+
+   def get(path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+      add_route(:GET, path, accepted_queries: accepted_queries, accepted_body: accepted_body, accepted_response: accepted_response, &block)
+   end
+
+   def post(path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+      add_route(:POST, path, accepted_queries: accepted_queries, accepted_body: accepted_body, accepted_response: accepted_response, &block)
+   end
+```
+
+### `Router`
+Handles route definitions and request matching. Supports dynamic routes, query validation, and request body validation.
+
+#### Key Features:
+- Define routes for `GET`, `POST`, `PUT`, and `DELETE` methods.
+- Validate query parameters and request bodies.
+- Support for dynamic route parameters with type constraints.
+
+```ruby
+class Router
+  def initialize
+    @routes = { GET: {}, POST: {}, PUT: {}, DELETE: {} }
+  end
+
+  def get(path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+    add_route(:GET, path, accepted_queries: accepted_queries, accepted_body: accepted_body, accepted_response: accepted_response, &block)
+  end
+end
+```
+
+### `HTTPResponse`
+Encapsulates HTTP responses with status codes, headers, and JSON bodies.
+
+#### Key Features:
+- Generates structured responses for the client.
+- Based on Rack return standard
+
+```ruby
+class HTTPResponse
+  def initialize(status, json)
+    @status = status
+    @headers = { 'Content-Type' => 'application/json' }
+    @body = [JSON.generate(json)]
+  end
+
+  def to_a
+    [@status, @headers, @body]
+  end
+end
+```
+
+## Usage
+
+## Conclusion
+
+This framework offers a clean, Ruby-based solution for building HTTP APIs, complete with dynamic routing, type validation, and asynchronous processing. By leveraging the power of Puma and Rack, it provides a high-performance and scalable foundation for your web applications.
+

data/lib/TeleRuby/app.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require 'puma'
+require 'rack'
+require 'json'
+
+require_relative 'router'
+
+class App
+  def initialize
+    @routers = {}
+  end
+
+  def add_router(path, router)
+    @routers[path] = router
+  end
+
+  def call(env)
+    # Use a Thread to handle the request asynchronously
+    result = nil
+    thread = Thread.new do
+      result = handle_request(env)
+    end
+    thread.join # Ensure the thread completes before returning
+    result # Return the result from the thread
+  end
+
+
+  def handle_request(env)
+    begin
+      if env["CONTENT_TYPE"] == "application/json"
+        request_body = JSON.parse(env["rack.input"].read)
+        env["parsed_body"] = request_body
+      end
+
+      query_params = Rack::Utils.parse_query(env["QUERY_STRING"])
+      env["query_params"] = query_params
+
+      full_path = env["PATH_INFO"]
+      method = env["REQUEST_METHOD"].to_sym
+
+      @routers.each do |base_path, router|
+        if full_path.start_with?(base_path)
+          sub_path = full_path.sub(base_path, "")
+          return router.call(sub_path, method, env, full_path)
+        end
+      end
+
+      json_response(404, { error: "Not Found" })
+    rescue => e
+      puts "[ERROR] #{e.message}"
+      puts e.backtrace.join("\n")
+      json_response(500, { error: "Internal Server Error" })
+    end
+  end
+
+
+  def run
+    puts "Starting Puma Server..."
+    server = Puma::Server.new(self)
+
+    server.add_tcp_listener('127.0.0.1', 3000) # Port setup
+
+    trap(:INT) do
+      puts "\nStopping the server..."
+      server.stop
+    end
+
+    puts "Server successfully started."
+    server.run
+    server.thread.join # Ensure server blocks the main thread
+  end
+
+  private
+
+  def json_response(status, data)
+    [
+      status,
+      { 'Content-Type' => 'application/json' },
+      [JSON.generate(data)]
+    ]
+  end
+end

data/lib/TeleRuby/http_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class HTTPResponse
+
+  attr_accessor :status, :headers, :body
+
+  def initialize(status, json)
+    @status = status
+    @headers = { 'Content-Type' => 'application/json' }
+    @body = [JSON.generate(json)]
+  end
+
+  def to_a
+    [@status, @headers, @body]
+  end
+end
+

data/lib/TeleRuby/router.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+require 'json'
+
+class Router
+  def initialize
+    @routes = { GET: {}, POST: {}, PUT: {}, DELETE: {} }
+  end
+
+  def add_route(method, path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+    @routes[method][path] = {
+      accepted_queries: accepted_queries,
+      accepted_body: accepted_body,
+      accepted_response: accepted_response,
+      handler: block
+    }
+  end
+
+  def get(path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+    add_route(:GET, path, accepted_queries: accepted_queries, accepted_body: accepted_body, accepted_response: accepted_response, &block)
+  end
+
+  def post(path, accepted_queries: nil, accepted_body: nil, accepted_response: nil, &block)
+    add_route(:POST, path, accepted_queries: accepted_queries, accepted_body: accepted_body, accepted_response: accepted_response, &block)
+  end
+
+  def call(path, method, env, full_path)
+    log_request(method, full_path)
+
+    unless @routes.key?(method)
+      log_response(405, "Method Not Allowed")
+      return json_response(405, { error: "Method Not Allowed" })
+    end
+
+    @routes[method].each do |route_path, route|
+      match = match_path(route_path, path)
+
+      if match
+        # If there's a match, extract URL parameters (if any)
+        if match.is_a?(MatchData)
+          env["url_params"] = match.named_captures || {}
+        else
+          env["url_params"] = {}
+        end
+
+        # Validate query parameters
+        if route[:accepted_queries] && !validate_queries(route[:accepted_queries], env["query_params"])
+          log_response(400, "Invalid Query Parameters")
+          return json_response(400, { error: "Invalid Query Parameters" })
+        end
+
+        # Validate body parameters
+        if route[:accepted_body] && !validate_body(route[:accepted_body], env["parsed_body"])
+          log_response(400, "Invalid Body Parameters")
+          return json_response(400, { error: "Invalid Body Parameters" })
+        end
+
+        # Call the handler block
+        result = route[:handler].call(env)
+
+        # Ensure result is an HTTPResponse and validate it
+        if result.is_a?(HTTPResponse)
+          if route[:accepted_response] && !validate_accepted_response(route[:accepted_response], result.body)
+            log_response(500, "Invalid Response Structure")
+            return json_response(500, { error: "Invalid Response Structure" })
+          end
+
+          log_response(result.status, result.body[0] || result.body[0])
+
+          return result.to_a # Convert HTTPResponse to Rack-compatible response
+        else
+          log_response(500, "Handler did not return an HTTPResponse")
+          return json_response(500, { error: "Handler must return an HTTPResponse" })
+        end
+      end
+    end
+
+    # If no match is found, return 404
+    log_response(404, "Not Found")
+    json_response(404, { error: "Not Found" })
+  end
+
+  private
+
+  def json_response(status, data)
+    [
+      status,
+      { 'Content-Type' => 'application/json' },
+      [JSON.generate(data)]
+    ]
+  end
+
+  def log_request(method, path)
+    method_color = case method
+                   when :GET then "\e[32m"  # Green for GET
+                   when :POST then "\e[34m" # Blue for POST
+                   when :PUT then "\e[33m"  # Yellow for PUT
+                   when :DELETE then "\e[31m" # Red for DELETE
+                   else "\e[37m" # White for others
+                   end
+    reset = "\e[0m"
+    puts "#{method_color}[REQUEST] Method: #{method} | Path: #{path}#{reset}"
+  end
+
+  def log_response(status, reason)
+    status_color = case status
+                   when 200 then "\e[32m"  # Green for success
+                   when 400 then "\e[33m"  # Yellow for client errors
+                   when 404 then "\e[31m"  # Red for not found
+                   when 405 then "\e[31m"  # Red for method not allowed
+                   when 500 then "\e[35m"  # Magenta for server errors
+                   else "\e[37m" # White for other statuses
+                   end
+    reset = "\e[0m"
+    puts "#{status_color}[RESPONSE] Status: #{status} | Reason: #{reason}#{reset}"
+  end
+
+  def match_path(route_path, request_path)
+    regex_path = route_path.gsub(/\$\{(\w+)(?::(\w+))?\}/) do |_match|
+      param_name = Regexp.last_match(1)
+      param_type = Regexp.last_match(2)
+
+      # Handle different types
+      case param_type
+      when "int"
+        "(?<#{param_name}>\\d+)" # Only digits
+      when "string", nil
+        "(?<#{param_name}>[^/]+)" # Default to any non-slash characters
+      else
+        raise "Unsupported type: #{param_type}"
+      end
+    end
+
+    Regexp.new("^#{regex_path}$").match(request_path)
+  end
+
+
+  def validate_accepted_response(accepted_response_class, response_body)
+    return false unless response_body.is_a?(Array) && response_body.first.is_a?(String)
+
+    parsed_json = JSON.parse(response_body.first, symbolize_names: true)
+
+    instance = accepted_response_class.new
+
+    parsed_json.each do |key, value|
+      return false unless instance.respond_to?("#{key}=")
+    end
+
+    true
+  end
+
+
+
+
+  def validate_queries(accepted_queries, query_params)
+    # Ensure all required queries are present in the query_params
+    accepted_queries.all? { |query| query_params.key?(query) }
+  end
+
+
+  def validate_body(accepted_body, parsed_body)
+
+    accepted_body.instance_variables.all? do |var|
+      parsed_body.key?(var.to_s.sub('@', ''))
+    end
+  end
+end

data/lib/TeleRuby.rb

@@ -0,0 +1,5 @@
+require "TeleRuby/app"
+require "TeleRuby/router"
+require "TeleRuby/http_response"
+# frozen_string_literal: true
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: HTTPRuby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bryan Sigaran
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: An HTTP server framework similar to FastAPI, featuring async processing,
+  dynamic routing, and type validation.
+email:
+- bryanohss@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/TeleRuby.rb
+- lib/TeleRuby/app.rb
+- lib/TeleRuby/http_response.rb
+- lib/TeleRuby/router.rb
+homepage: https://github.com/artisenpaiii/TeleRuby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: A lightweight HTTP server framework for Ruby
+test_files: []