RubyGems - itsi - Versions diffs - 0.1.14 → 0.1.18 - Mend

itsi 0.1.14 → 0.1.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (169) hide show

data/crates/itsi_server/src/default_responses/html/index.html ADDED Viewed

@@ -0,0 +1,238 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{{title}}</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --link-color: #0052cc;
+        --accent-color: #0052cc;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        padding: 2rem;
+      }
+      h1 {
+        font-size: 2.5rem;
+        margin-bottom: 1rem;
+        text-align: center;
+      }
+      table {
+        width: 100%;
+        border-collapse: collapse;
+        margin-top: 1rem;
+      }
+      th,
+      td {
+        padding: 0.5rem;
+        text-align: left;
+      }
+      tr:nth-child(even) {
+        background-color: #e9ecef;
+      }
+      th {
+        border-bottom: 2px solid #ccc;
+        position: relative;
+        cursor: pointer;
+      }
+      /* Sorted header arrow */
+      th .sort-arrow {
+        font-size: 0.8rem;
+        display: none;
+      }
+      th.sorted .sort-arrow {
+        display: inline;
+      }
+      a {
+        color: var(--link-color);
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+      .size {
+        text-align: right;
+      }
+      .date {
+        white-space: nowrap;
+      }
+      footer {
+        margin-top: 2rem;
+        text-align: center;
+        font-size: 0.9rem;
+        color: #555;
+      }
+      th.name-header > span {
+        display: inline-block;
+        width: 100%;
+      }
+      th.name-header input {
+        margin-top: 0.3rem;
+        font-size: 0.8rem;
+        width: 100%;
+        max-width: 200px;
+        border: 1px solid #ccc;
+        background: none;
+        border-radius: 12px;
+        padding: 5px 15px;
+      }
+      /* Responsive adjustments */
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 2.5rem;
+        }
+        th,
+        td {
+          padding: 0.4rem;
+        }
+        th {
+          vertical-align: top;
+        }
+        th.name-header input {
+          max-width: 150px;
+          font-size: 0.75rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Directory listing for {{directory}}</h1>
+    <table data-sort-asc="true" data-sorted-column="0">
+      <thead>
+        <tr>
+          <th data-type="text" data-column="0" class="name-header">
+            <span>Name <span class="sort-arrow">▲</span></span>
+            <input type="text" id="nameFilter" placeholder="Filter names" />
+          </th>
+          <th data-type="size" data-column="1">
+            Size <span class="sort-arrow"></span>
+          </th>
+          <th data-type="text" data-column="2">
+            Last Modified <span class="sort-arrow"></span>
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        {{rows}}
+      </tbody>
+    </table>
+    <footer>
+      <p>Served by Itsi Static Assets</p>
+    </footer>
+    <script>
+      document.addEventListener("DOMContentLoaded", function () {
+        const table = document.querySelector("table");
+        const headers = table.querySelectorAll("th");
+        const nameFilter = document.getElementById("nameFilter");
+        let currentSortedColumn = 0;
+        let ascending = true;
+        // Add sorting listeners
+        headers.forEach((header, index) => {
+          header.addEventListener("click", function (e) {
+            // Prevent clicks on the filter input from triggering a sort.
+            if (e.target.tagName.toLowerCase() === "input") return;
+            sortTable(index);
+            updateSortArrows(index, ascending);
+          });
+        });
+        // Filter rows as the user types.
+        nameFilter.addEventListener("input", function () {
+          filterTable(this.value);
+        });
+        function sortTable(columnIndex) {
+          const tbody = table.querySelector("tbody");
+          let rows = Array.from(tbody.querySelectorAll("tr"));
+          // If sorting on a new column, default to ascending.
+          if (currentSortedColumn !== columnIndex) {
+            ascending = true;
+            currentSortedColumn = columnIndex;
+          } else {
+            ascending = !ascending;
+          }
+          rows.sort((a, b) => {
+            let aText = a.cells[columnIndex].textContent.trim().toLowerCase();
+            let bText = b.cells[columnIndex].textContent.trim().toLowerCase();
+            // If sorting the file size column, convert sizes to bytes.
+            if (headers[columnIndex].getAttribute("data-type") === "size") {
+              aText = parseSize(aText);
+              bText = parseSize(bText);
+            }
+            if (aText < bText) return ascending ? -1 : 1;
+            if (aText > bText) return ascending ? 1 : -1;
+            return 0;
+          });
+          rows.forEach((row) => tbody.appendChild(row));
+          table.setAttribute("data-sort-asc", ascending.toString());
+          table.setAttribute("data-sorted-column", columnIndex.toString());
+        }
+        function updateSortArrows(sortedIndex, ascending) {
+          headers.forEach((header, index) => {
+            header.classList.remove("sorted");
+            const arrow = header.querySelector(".sort-arrow");
+            if (index === sortedIndex) {
+              header.classList.add("sorted");
+              arrow.textContent = ascending ? "▲" : "▼";
+            } else {
+              arrow.textContent = "";
+            }
+          });
+        }
+        function filterTable(filterValue) {
+          const tbody = table.querySelector("tbody");
+          const rows = Array.from(tbody.querySelectorAll("tr"));
+          const lowerFilter = filterValue.toLowerCase();
+          rows.forEach((row) => {
+            const nameCell = row.cells[0];
+            row.style.display = nameCell.textContent
+              .toLowerCase()
+              .includes(lowerFilter)
+              ? ""
+              : "none";
+          });
+        }
+        // Parse file size string (e.g., "12.3 KB") into a number (bytes)
+        function parseSize(sizeStr) {
+          sizeStr = sizeStr.trim();
+          if (sizeStr === "-" || sizeStr === "") return 0;
+          const parts = sizeStr.split(" ");
+          if (parts.length < 2) return parseFloat(parts[0]);
+          const value = parseFloat(parts[0]);
+          const unit = parts[1].toLowerCase();
+          switch (unit) {
+            case "b":
+              return value;
+            case "kb":
+              return value * 1024;
+            case "mb":
+              return value * 1024 * 1024;
+            case "gb":
+              return value * 1024 * 1024 * 1024;
+            default:
+              return value;
+          }
+        }
+      });
+    </script>
+  </body>
+</html>

data/crates/itsi_server/src/default_responses/json/401.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Unauthorized",
+  "message": "You are not authorized to access this resource.",
+  "code": 401,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/403.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Forbidden",
+  "message": "You are forbidden to access this resource.",
+  "code": 403,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/404.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Not Found",
+  "message": "The requested resource could not be found.",
+  "code": 404,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/413.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Payload Too Large",
+  "message": "The request entity is larger than the server is willing or able to process.",
+  "code": 413,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/429.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Too Many Requests",
+  "message": "Too many requests within a limited time frame.",
+  "code": 429,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/500.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Internal Server Error",
+  "message": "The server encountered an unexpected condition that prevented it from fulfilling the request.",
+  "code": 500,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/502.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Bad Gateway",
+  "message": "The server was acting as a gateway or proxy and received an invalid response from the upstream server.",
+  "code": 502,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/503.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Service Unavailable",
+  "message": "The server is currently unable to handle the request.",
+  "code": 503,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/json/504.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Gateway Timeout",
+  "message": "The server did not respond in time.",
+  "code": 504,
+  "status": "error"
+}

data/crates/itsi_server/src/default_responses/mod.rs ADDED Viewed

@@ -0,0 +1,11 @@
+use std::sync::LazyLock;
+use crate::server::middleware_stack::ErrorResponse;
+pub static TIMEOUT_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::gateway_timeout);
+pub static NOT_FOUND_RESPONSE: LazyLock<ErrorResponse> = LazyLock::new(ErrorResponse::not_found);
+pub static INTERNAL_SERVER_ERROR_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::internal_server_error);

data/crates/itsi_server/src/lib.rs CHANGED Viewed

@@ -1,16 +1,21 @@
+#![deny(unused_crate_dependencies)]
+pub mod default_responses;
+pub mod env;
+pub mod prelude;
+pub mod ruby_types;
+pub mod server;
+pub mod services;
 use magnus::{error::Result, function, method, Module, Object, Ruby};
+use prelude::*;
 use ruby_types::{
-    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_request::ItsiGrpcRequest,
-    itsi_grpc_stream::ItsiGrpcStream, itsi_http_request::ItsiHttpRequest,
-    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY,
-    ITSI_GRPC_REQUEST, ITSI_GRPC_RESPONSE, ITSI_GRPC_STREAM, ITSI_MODULE, ITSI_REQUEST,
-    ITSI_RESPONSE, ITSI_SERVER,
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_call::ItsiGrpcCall,
+    itsi_grpc_response_stream::ItsiGrpcResponseStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY, ITSI_GRPC_CALL,
+    ITSI_GRPC_RESPONSE_STREAM, ITSI_MODULE, ITSI_REQUEST, ITSI_RESPONSE, ITSI_SERVER,
 };
 use server::signal::reset_signal_handlers;
-use tracing::*;
-pub mod env;
-pub mod ruby_types;
-pub mod server;
+use services::password_hasher;
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
@@ -24,6 +29,10 @@ fn init(ruby: &Ruby) -> Result<()> {
     itsi.define_singleton_method("log_info", function!(log_info, 1))?;
     itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;
     itsi.define_singleton_method("log_error", function!(log_error, 1))?;
+    itsi.define_singleton_method(
+        "create_password_hash",
+        function!(password_hasher::create_password_hash, 2),
+    )?;
     let server = ruby.get_inner(&ITSI_SERVER);
     server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
@@ -35,7 +44,15 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("path", method!(ItsiHttpRequest::path, 0))?;
     request.define_method("script_name", method!(ItsiHttpRequest::script_name, 0))?;
     request.define_method("query_string", method!(ItsiHttpRequest::query_string, 0))?;
-    request.define_method("method", method!(ItsiHttpRequest::method, 0))?;
+    request.define_method(
+        "content_type",
+        method!(ItsiHttpRequest::content_type_str, 0),
+    )?;
+    request.define_method(
+        "content_length",
+        method!(ItsiHttpRequest::content_length, 0),
+    )?;
+    request.define_method("request_method", method!(ItsiHttpRequest::method, 0))?;
     request.define_method("version", method!(ItsiHttpRequest::version, 0))?;
     request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
     request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
@@ -49,6 +66,9 @@ fn init(ruby: &Ruby) -> Result<()> {
     request.define_method("response", method!(ItsiHttpRequest::response, 0))?;
     request.define_method("json?", method!(ItsiHttpRequest::is_json, 0))?;
     request.define_method("html?", method!(ItsiHttpRequest::is_html, 0))?;
+    request.define_method("url_encoded?", method!(ItsiHttpRequest::is_url_encoded, 0))?;
+    request.define_method("multipart?", method!(ItsiHttpRequest::is_multipart, 0))?;
+    request.define_method("url_params", method!(ItsiHttpRequest::url_params, 0))?;
     let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
     body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
@@ -73,27 +93,39 @@ fn init(ruby: &Ruby) -> Result<()> {
     response.define_method("close_read", method!(ItsiHttpResponse::close_read, 0))?;
     response.define_method("close", method!(ItsiHttpResponse::close, 0))?;
     response.define_method("hijack", method!(ItsiHttpResponse::hijack, 1))?;
+    response.define_method("accept", method!(ItsiHttpResponse::accept_str, 0))?;
     response.define_method("json?", method!(ItsiHttpResponse::is_json, 0))?;
     response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
-    let grpc_request = ruby.get_inner(&ITSI_GRPC_REQUEST);
-    grpc_request.define_method("service_name", method!(ItsiGrpcRequest::service_name, 0))?;
-    grpc_request.define_method("method_name", method!(ItsiGrpcRequest::method_name, 0))?;
-    grpc_request.define_method("stream", method!(ItsiGrpcRequest::stream, 0))?;
-    grpc_request.define_method("json?", method!(ItsiGrpcRequest::is_json, 0))?;
-    grpc_request.define_method(
-        "content_type",
-        method!(ItsiGrpcRequest::content_type_str, 0),
+    let grpc_call = ruby.get_inner(&ITSI_GRPC_CALL);
+    grpc_call.define_method("service_name", method!(ItsiGrpcCall::service_name, 0))?;
+    grpc_call.define_method("method_name", method!(ItsiGrpcCall::method_name, 0))?;
+    grpc_call.define_method("stream", method!(ItsiGrpcCall::stream, 0))?;
+    grpc_call.define_method("json?", method!(ItsiGrpcCall::is_json, 0))?;
+    grpc_call.define_method("content_type", method!(ItsiGrpcCall::content_type_str, 0))?;
+    grpc_call.define_method("timeout", method!(ItsiGrpcCall::timeout, 0))?;
+    grpc_call.define_method("cancelled?", method!(ItsiGrpcCall::is_cancelled, 0))?;
+    grpc_call.define_method("add_headers", method!(ItsiGrpcCall::add_headers, 1))?;
+    grpc_call.define_method("compress_output", method!(ItsiGrpcCall::compress_output, 1))?;
+    grpc_call.define_method(
+        "decompress_input",
+        method!(ItsiGrpcCall::decompress_input, 1),
+    )?;
+    grpc_call.define_method(
+        "should_compress_output?",
+        method!(ItsiGrpcCall::should_compress_output, 1),
     )?;
-    let grpc_stream = ruby.get_inner(&ITSI_GRPC_STREAM);
-    grpc_stream.define_method("read", method!(ItsiGrpcStream::read, 1))?;
-    grpc_stream.define_method("write", method!(ItsiGrpcStream::write, 1))?;
-    grpc_stream.define_method("flush", method!(ItsiGrpcStream::flush, 0))?;
-    grpc_stream.define_method("send_trailers", method!(ItsiGrpcStream::send_trailers, 1))?;
-    let _grpc_response = ruby.get_inner(&ITSI_GRPC_RESPONSE);
+    let grpc_response_stream = ruby.get_inner(&ITSI_GRPC_RESPONSE_STREAM);
+    grpc_response_stream
+        .define_method("reader_fileno", method!(ItsiGrpcResponseStream::reader, 0))?;
+    grpc_response_stream.define_method("write", method!(ItsiGrpcResponseStream::write, 1))?;
+    grpc_response_stream.define_method("flush", method!(ItsiGrpcResponseStream::flush, 0))?;
+    grpc_response_stream.define_method(
+        "send_trailers",
+        method!(ItsiGrpcResponseStream::send_trailers, 1),
+    )?;
+    grpc_response_stream.define_method("close", method!(ItsiGrpcResponseStream::close, 0))?;
     Ok(())
 }

data/crates/itsi_server/src/prelude.rs ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ pub use itsi_error::*;
2	+ pub use itsi_tracing::{debug, error, info, trace, warn};

data/crates/itsi_server/src/ruby_types/README.md ADDED Viewed

@@ -0,0 +1,21 @@
+---
+title: Itsi Server Twp
+type: docs
+prev: /crates/itsi_server/test
+next: docs/folder/
+---
+# Deep nested Foo
+This is a demo of the theme's documentation layout.
+## Hello, World!
+```go {filename="main.go"}
+package main
+import "fmt"
+func main() {
+    fmt.Println("Hello, World!")
+}
+```

data/crates/itsi_server/src/ruby_types/itsi_body_proxy/mod.rs CHANGED Viewed

@@ -12,10 +12,12 @@ use std::sync::{
 };
 use tokio_stream::StreamExt;
+use crate::server::size_limited_incoming::SizeLimitedIncoming;
 #[magnus::wrap(class = "Itsi::BodyProxy", free_immediately, size)]
 #[derive(Debug, Clone)]
 pub struct ItsiBodyProxy {
-    pub incoming: Arc<Mutex<BodyDataStream<Incoming>>>,
+    pub incoming: Arc<Mutex<BodyDataStream<SizeLimitedIncoming<Incoming>>>>,
     pub closed: Arc<AtomicBool>,
     pub buf: Arc<Mutex<Vec<u8>>>,
 }
@@ -34,7 +36,7 @@ impl ItsiBody {
     }
 }
 impl ItsiBodyProxy {
-    pub fn new(incoming: Incoming) -> Self {
+    pub fn new(incoming: SizeLimitedIncoming<Incoming>) -> Self {
         ItsiBodyProxy {
             incoming: Arc::new(Mutex::new(incoming.into_data_stream())),
             closed: Arc::new(AtomicBool::new(false)),
@@ -50,7 +52,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -82,7 +84,7 @@ impl ItsiBodyProxy {
             if let Some(chunk) = block_on(stream.next()) {
                 let chunk = chunk.map_err(|err| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Error reading body {:?}", err),
                     )
                 })?;
@@ -107,7 +109,7 @@ impl ItsiBodyProxy {
         while let Some(chunk) = block_on(stream.next()) {
             let chunk = chunk.map_err(|err| {
                 magnus::Error::new(
-                    magnus::exception::exception(),
+                    magnus::exception::standard_error(),
                     format!("Error reading body {:?}", err),
                 )
             })?;
@@ -129,7 +131,7 @@ impl ItsiBodyProxy {
     fn verify_open(&self) -> MagnusResult<()> {
         if self.closed.load(atomic::Ordering::SeqCst) {
             return Err(magnus::Error::new(
-                magnus::exception::exception(),
+                magnus::exception::standard_error(),
                 "Body stream is closed",
             ));
         }