voffie_teapot 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3887b642309860f8590ab04c04c0e4c74717259fd4c6a294c72db4f219e1bed4
+  data.tar.gz: 993c9a2abdc2c34665b65cb74fbe192b4fb359f9cffc69a37bb3f01338ba5a3f
+SHA512:
+  metadata.gz: 2397220b9073b29a4232a8481f16f6de00c189f82680a0268e6cbe8bfaf3ddfd67cd6439fe55c46abc947d3c0e840f91dec9f687574a86160b91d52bccb5ab97
+  data.tar.gz: 99d4343ab27b38565d0b5f515605581f31d01de9c9c725cd0d2cfb5c2c9decf9830410b1f97944f341cac6847446bbadb8d6be0e0705a0e1a1f87dc388d8a37a

data/lib/voffie_teapot/get_handler.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'voffie_teapot/response'
+require 'voffie_teapot/resource_manager'
+
+module VoffieTeapot
+  # GET implementation of HTTPHandler
+  class GetHandler < HTTPHandler
+    include ResourceManager
+
+    def handle(request)
+      if matches?(request[:resource])
+        route_params = extract_params(request[:resource])
+        request[:params] = route_params
+
+        response = Response.new
+        response.change_content_type('text/html; charset=utf-8')
+        begin
+          @block.call(request, response)
+          return response
+        rescue StandardError => e
+          return Response.default500(e)
+        end
+      end
+
+      handle_static_resource(request)
+    end
+
+    private
+
+    def handle_static_resource(request)
+      if request[:Accept]&.include?('text/css')
+        handle_css(request)
+      elsif IMG_CONTENT_TYPES.keys.include?(request[:resource].split('.').last.to_sym)
+        handle_image(request)
+      elsif request[:resource].end_with?('.js', '.ts')
+        handle_script(request)
+      else
+        Response.default404(request[:resounce])
+      end
+    end
+
+    def handle_css(request)
+      value = css(request[:resource])
+      if value[:status] == 200
+        Response.new(200, value[:file], { 'Content-Type' => 'text/css' })
+      else
+        Response.default404(request[:resource])
+      end
+    end
+
+    def handle_image(request)
+      value = load_img(request[:resource])
+      if value[:status] == 200
+        response = Response.new(200, value[:file])
+        response.change_content_type(value[:ct])
+        response.change_content_length(value[:size])
+        response
+      else
+        Response.default404(request[:resource])
+      end
+    end
+
+    def handle_script(request)
+      value = load_script(request[:resource])
+      if value[:status] == 200
+        Response.new(200, value[:file], { 'Content-Type' => '*/*' })
+      else
+        Response.default404(request[:resource])
+      end
+    end
+  end
+end

data/lib/voffie_teapot/http_handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'voffie_teapot/utils'
+
+module VoffieTeapot
+  # Abstract class for HTTP method handlers
+  class HTTPHandler
+    include Utils
+
+    def initialize(path, block = nil)
+      @path = path
+      @regex = generate_reg_exp(path) if path
+      @block = block
+      @param_names = extract_param_names(path)
+    end
+
+    def matches?(path)
+      return false unless @regex
+
+      @regex.match?(path)
+    end
+
+    def extract_params(resource)
+      return {} unless resource.is_a?(String) && @path.is_a?(String)
+
+      param_names = extract_param_names(resource)
+      match_data = @regex.match(resource)
+
+      return {} unless param_names.any? && match_data
+
+      @param_names.zip(match_data.captures).to_h
+    end
+
+    def handle(request)
+      raise NotImplementedError, 'You must implement the `handle` method in a subclass.'
+    end
+
+    private
+
+    def extract_param_names(resource)
+      return [] unless resource.is_a?(String) && @path.is_a?(String)
+
+      path_segments = @path.split('/')
+      resource_segments = resource.split('/')
+
+      return [] if path_segments.size != resource_segments.size
+
+      path_segments.select { |segment| segment.start_with?(':') }.map { |param| param[1..].to_sym }
+    end
+  end
+end

data/lib/voffie_teapot/main.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'voffie_teapot/parser'
+require 'voffie_teapot/response'
+require 'voffie_teapot/http_handler'
+require 'voffie_teapot/get_handler'
+require 'voffie_teapot/post_handler'
+
+module VoffieTeapot
+  # Base class for Teapot gem
+  class Main
+    include Parser
+
+    def initialize(port)
+      @server = TCPServer.new(port)
+      @running = true
+      @routes = { 'GET' => [], 'POST' => [] }
+      @middleware = []
+
+      Signal.trap('INT') do
+        puts "\nShutting down server..."
+        close
+      end
+    end
+
+    def close
+      @running = false
+      @server.close
+    end
+
+    def listen
+      puts "Teapot server started. Listening on port #{@server.addr[1]}..."
+
+      while @running
+        socket = @server.accept
+        Thread.new { handle_connection(socket) }
+      end
+    end
+
+    def get(path, &block)
+      @routes['GET'] << GetHandler.new(path, block)
+    end
+
+    def post(path, &block)
+      @routes['POST'] << PostHandler.new(path, block)
+    end
+
+    def use(path, &middleware)
+      @middleware << { path: path, middleware: middleware }
+    end
+
+    def process_middleware(request, response)
+      matching_middleware = @middleware.select { |m| match_route(m[:path], request[:resource]) }
+
+      matching_middleware.each do |middleware|
+        res = middleware[:middleware].call(request, response)
+        return res if res.is_a?(Response)
+      end
+    end
+
+    def match_route(route, resource)
+      return true if route == '*'
+
+      route_segments = route.split('/')
+      resource_segments = resource.split('/')
+
+      return false if route_segments.length != resource_segments.length
+
+      route_segments.each_with_index do |_segments, index|
+        if segment.start_with?(':')
+          next
+        elsif segment != resource_segments[index]
+          return false
+        end
+      end
+
+      true
+    end
+
+    def handle_connection(socket)
+      request = read_request(socket)
+      return unless request
+
+      parsed_request = parse(request)
+      if parsed_request[:Content_Length].to_i.positive?
+        parsed_request[:body] = JSON.parse(socket.read(parsed_request[:Content_Length].to_i))
+        parsed_request[:body] = parsed_request[:body].transform_keys(&:to_sym)
+      end
+
+      response = route_request(parsed_request).create_response
+      socket.print response
+      socket.close
+    end
+
+    def read_request(socket)
+      request = ''
+      while (line = socket.gets) && line !~ /^\s*$/
+        request += line
+      end
+      request.empty? ? nil : request
+    end
+
+    def route_request(request)
+      response = Response.new
+      process_middleware(request, response)
+
+      return response unless response.body == ''
+
+      method = request[:method]
+      return Response.default404(request[:path]) unless @routes.key?(method)
+
+      handler = @routes[method].find { |h| h.matches?(request[:resource]) }
+      if handler
+        response = handler.handle(request)
+        return response.is_a?(Response) ? response : Response.default404(request[:path])
+      end
+
+      response =
+        case method
+        when 'GET'
+          GetHandler.new(nil).handle(request)
+        when 'POST'
+          PostHandler.new(nil).handle(request)
+        end
+
+      response.is_a?(Response) ? response : Response.default404(request[:path])
+    end
+  end
+end

data/lib/voffie_teapot/parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+VALID_METHODS = %w[GET POST PUT DELETE PATCH].freeze
+
+module VoffieTeapot
+  # Parser module to parse HTTP requests
+  module Parser
+    def parse(request)
+      lines = request.split("\n")
+      return nil if lines[0].nil?
+
+      method, resource, http = lines[0].split
+      parsed_request = {}
+
+      if VALID_METHODS.include?(method)
+        parsed_request[:method] = method
+        parsed_request[:resource] = resource
+        parsed_request[:http] = http
+        lines[1..].each do |row|
+          key, val = row.split(': ', 2)
+          next if key.nil? || val.nil?
+
+          parsed_request[key.gsub('-', '_').to_sym] = val.strip
+        end
+      else
+        parsed_request[:error] = "Invalid method: #{method}"
+      end
+      parsed_request
+    rescue StandardError => e
+      { error: "Error parsing request: #{e.message}" }
+    end
+  end
+end

data/lib/voffie_teapot/post_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module VoffieTeapot
+  # POST implementation of HTTPHandler
+  class PostHandler < HTTPHandler
+    def handle(request)
+      return unless matches?(request[:resource])
+
+      response = Response.new
+      begin
+        @block.call(request, response)
+      rescue StandardError => e
+        return Response.default500(e)
+      end
+      response
+    end
+  end
+end

data/lib/voffie_teapot/resource_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'slim'
+
+IMG_CONTENT_TYPES = {
+  apng: 'image/apng', avif: 'image/avif', gif: 'image/gif',
+  jpg: 'image/jpeg', jpeg: 'image/jpeg', jfif: 'image/jpeg',
+  pjpeg: 'image/jpeg', pjp: 'image/jpeg', png: 'image/png',
+  svg: 'image/svg+xml', webp: 'image/webp'
+}.freeze
+
+module VoffieTeapot
+  # Module to handle loading/generating resources
+  module ResourceManager
+    def load_slim(resource, locals = {}, layout: true)
+      content = read_file("./views/#{resource}.slim")
+      layout_content = layout ? read_file('./views/layout.slim') : nil
+
+      rendered = Slim::Template.new { content }.render(nil, locals)
+      layout ? Slim::Template.new { layout_content }.render { rendered } : rendered
+    rescue StandardError => e
+      "Error rendering template #{e.message}"
+    end
+
+    def css(resource)
+      load_public_file(resource, 'text/css')
+    end
+
+    def load_img(resource)
+      load_public_file(resource, IMG_CONTENT_TYPES[resource.split('.').last.to_sym])
+    end
+
+    def load_script(resource)
+      load_public_file(resource, '*/*')
+    end
+
+    private
+
+    def load_public_file(resource, content_type)
+      normalized_resource = resource.start_with?('/') ? resource[1..] : resource
+      path = "./public/#{normalized_resource}"
+      if File.file?(path)
+        { file: File.read(path), ct: content_type, status: 200, size: File.size(path) }
+      else
+        { status: 404 }
+      end
+    end
+
+    def read_file(path)
+      File.read(path)
+    rescue Errno::ENOENT
+      raise "File not found #{path}"
+    end
+  end
+end

data/lib/voffie_teapot/response.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'voffie_teapot/resource_manager'
+
+module VoffieTeapot
+  # Response class to handle/generate responses
+  class Response
+    include ResourceManager
+    attr_accessor :body, :status, :header
+
+    def initialize(status = 200, body = '', header = {})
+      @status = status
+      @body = body
+      @header = header
+      @cookies = {}
+    end
+
+    def self.default404(route)
+      body = load_error_page('404.html', { route: route })
+      new(404, body, { 'Content-Type' => 'text/html' })
+    end
+
+    def self.default500(error)
+      body = load_error_page('500.html', { error_message: error.message, error_class: error.class, backtrace: error.backtrace })
+      new(500, body, { 'Content-Type' => 'text/html' })
+    end
+
+    def self.load_error_page(filename, locals = {})
+      user_path = "./views/#{filename}"
+      gem_path = File.join(Gem::Specification.find_by_name('voffie_teapot').gem_dir, 'lib', 'voffie_teapot', 'views', filename)
+
+      if File.exist?(user_path)
+        template = File.read(user_path)
+      else
+        return '<html><body><h1>Error loading template</h1></body></html>' unless File.exist?(gem_path)
+
+        template = File.read(gem_path)
+      end
+
+      locals.each do |key, value|
+        template.gsub!("<%= #{key} %>", value.to_s)
+      end
+
+      template
+    rescue Errno::ENOENT
+      '<html><body><h1>Error loading template</h1></body></html>'
+    end
+
+    def create_cookie(name, value)
+      @cookies[name] = value
+    end
+
+    def change_status(status)
+      @status = status
+    end
+
+    def change_content_type(type)
+      @header['Content-Type'] = type
+    end
+
+    def change_content_length(length)
+      @header['Content-Length'] = length.to_s
+    end
+
+    def create_response
+      headers = @header.to_a.map { |key, value| "#{key}: #{value}" }.join("\r\n")
+      cookies = @cookies.to_a.map { |key, value| "Set-Cookie: #{key}=#{value}" }.join("\r\n")
+      response = "HTTP/1.1 #{@status}\r\n#{headers}\r\n"
+      response += "#{cookies}\r\n" unless cookies.empty?
+      response + "\r\n#{@body}"
+    end
+
+    def redirect(location)
+      @header['Location'] = location
+      change_status(301)
+    end
+
+    def slim(resource, locals = {}, layout: true)
+      load_slim(resource, locals, layout: layout)
+    end
+  end
+end

data/lib/voffie_teapot/utils.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module VoffieTeapot
+  # Module containing all utility methods required
+  module Utils
+    def generate_reg_exp(path)
+      return %r{^/$} if path == '/'
+
+      Regexp.new("^#{path.split('/').map do |segment|
+        segment.start_with?(':') ? '([^/]+)' : Regexp.escape(segment)
+      end.join('/')}$")
+    end
+  end
+end

data/lib/voffie_teapot/version.rb

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

data/lib/voffie_teapot/views/404.html

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html lang='en'>
+
+<head>
+  <meta charset='UTF-8' />
+  <meta name='viewport' content='width=device-width, initial-scale=1.0' />
+  <title>404 - Not Found</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background-color: #e0f2f1;
+      color: #004d40;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      padding: 20px;
+      box-sizing: border-box;
+    }
+
+    .container {
+      text-align: center;
+      background-color: #fff;
+      border-radius: 8px;
+      padding: 40px;
+      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+      max-width: 600px;
+      width: 100%;
+    }
+
+    h1 {
+      margin-top: 0;
+      color: #00796b;
+    }
+
+    .teapot {
+      font-size: 48px;
+      margin-bottom: 20px;
+    }
+  </style>
+</head>
+
+<body>
+  <div class="container">
+    <div class="teapot">🫖</div>
+    <h1>404 - Page Not Found</h1>
+    <p>Oh no! It seems you've stumbled upon an empty teacup. The page you're looking for has vanished like steam from a
+      hot brew.</p>
+    <p>Why not try steeping a fresh URL or returning to our <a href="/">homepage</a></p>
+  </div>
+</body>
+
+</html>

data/lib/voffie_teapot/views/500.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html lang='en'>
+
+<head>
+  <meta charset='UTF-8' />
+  <meta name='viewport' content='width=device-width, initial-scale=1.0' />
+  <title>500 - Internal Server Error</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background-color: #f0e6d2;
+      color: #5d4037;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      padding: 20px;
+      box-sizing: border-box;
+    }
+
+    .container {
+      text-align: center;
+      background-color: #fff;
+      border-radius: 8px;
+      padding: 40px;
+      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+      max-width: 600px;
+      width: 100%;
+    }
+
+    h1 {
+      margin-top: 0;
+      color: #d32f2f;
+    }
+
+    .teapot {
+      font-size: 48px;
+      margin-bottom: 20px;
+    }
+
+    pre {
+      background-color: #f5f5f5;
+      padding: 15px;
+      border-radius: 4px;
+      overflow-x: auto;
+      text-align: left;
+      white-space: pre-line;
+    }
+  </style>
+</head>
+
+<body>
+  <div class="container">
+    <div class="teapot">🫖</div>
+    <h1>500 - Internal Server Error</h1>
+    <p>Oops! It seems our teapot has overflowed. We're mopping up the mess and will be back shortly.</p>
+    <p>Error details: <strong>
+        <%= error_class %> - <%= error_message %>
+      </strong>
+    </p>
+    <pre id="error-details">
+      <%= backtrace %>
+    </pre>
+  </div>
+</body>
+
+</html>

data/lib/voffie_teapot.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'voffie_teapot/main'
+
+# Main module for the Teapot gem
+module VoffieTeapot
+  def self.new(...)
+    Main.new(...)
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: voffie_teapot
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Voffie
+bindir: bin
+cert_chain: []
+date: 2025-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+description: A web server using Ruby's built-in TCPServer class & web sockets
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/voffie_teapot.rb
+- lib/voffie_teapot/get_handler.rb
+- lib/voffie_teapot/http_handler.rb
+- lib/voffie_teapot/main.rb
+- lib/voffie_teapot/parser.rb
+- lib/voffie_teapot/post_handler.rb
+- lib/voffie_teapot/resource_manager.rb
+- lib/voffie_teapot/response.rb
+- lib/voffie_teapot/utils.rb
+- lib/voffie_teapot/version.rb
+- lib/voffie_teapot/views/404.html
+- lib/voffie_teapot/views/500.html
+homepage: https://github.com/voffie/teapot
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/voffie/teapot
+  bug_tracker_uri: https://github.com/voffie/teapot/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.0.dev
+specification_version: 4
+summary: TCP based web server
+test_files: []