luna 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e347831d31d4b1db1333c5bfb7ff3399fa58a95c5f776dcd68b2e8e8bd65987
+  data.tar.gz: 345be967db13b5f0368e2e576be3603fb6817c0dd6fbc9dce34ead65148ead17
+SHA512:
+  metadata.gz: c159538036c29eb07e69bedcc79fa882e6dd3117acf79db1a1971034586230a63335f0856ad6b1cdc082675d938c5c631f3c1770cbfae5b3fa87c1ef93df7471
+  data.tar.gz: 0444b5af72dbb9cf8845e3aecbcdc5d1eba3b97af656b23ca828362155cd8b683a300ffd10619cbda79c109b10988346770b4d3a8a393da814ea4cb078831952

data/agents.md

@@ -0,0 +1,205 @@
+# Agent
+
+## Context
+
+This section provides links to documentation from installed packages. It is automatically generated and may be updated by running `bake agent:context:install`.
+
+**Important:** Before performing any code, documentation, or analysis tasks, always read and apply the full content of any relevant documentation referenced in the following sections. These context files contain authoritative standards and best practices for documentation, code style, and project-specific workflows. **Do not proceed with any actions until you have read and incorporated the guidance from relevant context files.**
+
+**Setup Instructions:** If the referenced files are not present or if dependencies have been updated, run `bake agent:context:install` to install the latest context files.
+
+### agent-context
+
+Install and manage context files from Ruby gems.
+
+#### [Getting Started](.context/agent-context/getting-started.md)
+
+This guide explains how to use `agent-context`, a tool for discovering and installing contextual information from Ruby gems to help AI agents.
+
+### async
+
+A concurrency framework for Ruby.
+
+#### [Getting Started](.context/async/getting-started.md)
+
+This guide shows how to add async to your project and run code asynchronously.
+
+#### [Scheduler](.context/async/scheduler.md)
+
+This guide gives an overview of how the scheduler is implemented.
+
+#### [Tasks](.context/async/tasks.md)
+
+This guide explains how asynchronous tasks work and how to use them.
+
+#### [Best Practices](.context/async/best-practices.md)
+
+This guide gives an overview of best practices for using Async.
+
+#### [Debugging](.context/async/debugging.md)
+
+This guide explains how to debug issues with programs that use Async.
+
+#### [Thread safety](.context/async/thread-safety.md)
+
+This guide explains thread safety in Ruby, focusing on fibers and threads, common pitfalls, and best practices to avoid problems like data corruption, race conditions, and deadlocks.
+
+### async-http
+
+A HTTP client and server library.
+
+#### [Getting Started](.context/async-http/getting-started.md)
+
+This guide explains how to get started with `Async::HTTP`.
+
+#### [Testing](.context/async-http/testing.md)
+
+This guide explains how to use `Async::HTTP` clients and servers in your tests.
+
+### bake
+
+A replacement for rake with a simpler syntax.
+
+#### [Getting Started](.context/bake/getting-started.md)
+
+This guide gives a general overview of `bake` and how to use it.
+
+#### [Command Line Interface](.context/bake/command-line-interface.md)
+
+The `bake` command is broken up into two main functions: `list` and `call`.
+
+#### [Project Integration](.context/bake/project-integration.md)
+
+This guide explains how to add `bake` to a Ruby project.
+
+#### [Gem Integration](.context/bake/gem-integration.md)
+
+This guide explains how to add `bake` to a Ruby gem and export standardised tasks for use by other gems and projects.
+
+#### [Input and Output](.context/bake/input-and-output.md)
+
+`bake` has built in tasks for reading input and writing output in different formats. While this can be useful for general processing, there are some limitations, notably that rich object representations like `json` and `yaml` often don't support stream processing.
+
+### covered
+
+A modern approach to code coverage.
+
+#### [Getting Started](.context/covered/getting-started.md)
+
+This guide explains how to get started with `covered` and integrate it with your test suite.
+
+#### [Configuration](.context/covered/configuration.md)
+
+This guide will help you to configure covered for your project's specific requirements.
+
+### io-event
+
+An event loop.
+
+#### [Getting Started](.context/io-event/getting-started.md)
+
+This guide explains how to use `io-event` for non-blocking IO.
+
+### metrics
+
+Application metrics and instrumentation.
+
+#### [Getting Started](.context/metrics/getting-started.md)
+
+This guide explains how to use `metrics` for capturing run-time metrics.
+
+#### [Capture](.context/metrics/capture.md)
+
+This guide explains how to use `metrics` for exporting metric definitions from your application.
+
+#### [Testing](.context/metrics/testing.md)
+
+This guide explains how to write assertions in your test suite to validate `metrics` are being emitted correctly.
+
+### protocol-http
+
+Provides abstractions to handle HTTP protocols.
+
+#### [Getting Started](.context/protocol-http/getting-started.md)
+
+This guide explains how to use `protocol-http` for building abstract HTTP interfaces.
+
+#### [Message Body](.context/protocol-http/message-body.md)
+
+This guide explains how to work with HTTP request and response message bodies using `Protocol::HTTP::Body` classes.
+
+#### [Headers](.context/protocol-http/headers.md)
+
+This guide explains how to work with HTTP headers using `protocol-http`.
+
+#### [Middleware](.context/protocol-http/middleware.md)
+
+This guide explains how to build and use HTTP middleware with `Protocol::HTTP::Middleware`.
+
+#### [Streaming](.context/protocol-http/streaming.md)
+
+This guide gives an overview of how to implement streaming requests and responses.
+
+#### [Design Overview](.context/protocol-http/design-overview.md)
+
+This guide explains the high level design of `protocol-http` in the context of wider design patterns that can be used to implement HTTP clients and servers.
+
+### protocol-http1
+
+A low level implementation of the HTTP/1 protocol.
+
+#### [Getting Started](.context/protocol-http1/getting-started.md)
+
+This guide explains how to get started with `protocol-http1`, a low-level implementation of the HTTP/1 protocol for building HTTP clients and servers.
+
+### protocol-http2
+
+A low level implementation of the HTTP/2 protocol.
+
+#### [Getting Started](.context/protocol-http2/getting-started.md)
+
+This guide explains how to use the `protocol-http2` gem to implement a basic HTTP/2 client.
+
+### samovar
+
+Samovar is a flexible option parser excellent support for sub-commands and help documentation.
+
+#### [Getting Started](.context/samovar/getting-started.md)
+
+This guide explains how to use `samovar` to build command-line tools and applications.
+
+### sus
+
+A fast and scalable test runner.
+
+#### [Getting Started](.context/sus/getting-started.md)
+
+This guide explains how to use the `sus` gem to write tests for your Ruby projects.
+
+### sus-fixtures-async-http
+
+Test fixtures for running in Async::HTTP.
+
+#### [Getting Started](.context/sus-fixtures-async-http/getting-started.md)
+
+This guide explains how to use the `sus-fixtures-async-http` gem to test HTTP clients and servers.
+
+### traces
+
+Application instrumentation and tracing.
+
+#### [Getting Started](.context/traces/getting-started.md)
+
+This guide explains how to use `traces` for tracing code execution.
+
+#### [Context Propagation](.context/traces/context-propagation.md)
+
+This guide explains how to propagate trace context between different execution contexts within your application using `Traces.current_context` and `Traces.with_context`.
+
+#### [Testing](.context/traces/testing.md)
+
+This guide explains how to test traces in your code.
+
+#### [Capture](.context/traces/capture.md)
+
+This guide explains how to use `traces` for exporting traces from your application. This can be used to document all possible traces.

data/bin/luna

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025.
+
+require_relative "../lib/luna"
+require_relative "../lib/luna/command"
+
+exit Luna::Command.call(*ARGV)

data/examples/static/README.md

@@ -0,0 +1,7 @@
+# Luna Example
+
+This markdown file should be rendered to HTML when `--markdown` is enabled.
+
+- Item 1
+- Item 2
+- Item 3

data/examples/static/index.html

@@ -0,0 +1,6 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Luna Example</title>
+<h1>Hello from Luna</h1>
+<p>This is a static HTML file.</p>
+<p>Try <a href="README.md">README.md</a> for Markdown rendering.</p>

data/lib/luna/command/serve.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "samovar"
+require "async"
+require "async/http/endpoint"
+
+require_relative "../server"
+
+module Luna
+	module Command
+		class Serve < Samovar::Command
+			self.description = "Serve static files from a directory."
+			
+			options do
+				option "-b/--bind <address>", "Bind address (e.g. http://localhost:3000)", default: "http://localhost:3000"
+				option "-p/--port <number>", "Override port", type: Integer
+				option "-h/--hostname <hostname>", "Override hostname"
+				option "-t/--timeout <seconds>", "I/O timeout", type: Float, default: nil
+				
+				option "-r/--root <path>", "Root directory", default: nil
+				option "-i/--index <filename>", "Directory index", default: "index.html"
+				option "--[no]-directory-listing", "Enable directory listing", default: true
+				option "--[no]-markdown", "Enable Markdown rendering", default: true
+				option "-v/--[no]-verbose", "Verbose logging", default: false
+			end
+			
+			# Optional positional argument for root directory
+			one :path, "Root directory to serve", default: nil
+			
+			def root_directory
+				# Use positional argument if provided, otherwise --root option, otherwise current directory
+				if @path
+					@path
+				elsif @options[:root]
+					@options[:root]
+				else
+					Dir.pwd
+				end
+			end
+			
+			def endpoint_options
+				@options.slice(:hostname, :port, :timeout)
+			end
+			
+			def endpoint
+				Async::HTTP::Endpoint.parse(@options[:bind], **endpoint_options)
+			end
+			
+			def middleware
+				Luna::Server.middleware(
+					root: File.expand_path(root_directory),
+					verbose: @options[:verbose],
+					markdown: @options[:markdown],
+					index: @options[:index],
+					directory_listing: @options[:directory_listing]
+				)
+			end
+			
+			def call
+				Console.logger.info(self) do |buffer|
+					buffer.puts "Luna v#{Luna::VERSION} serving..."
+					buffer.puts "- Root: #{File.expand_path(root_directory)}"
+					buffer.puts "- Bind: #{endpoint}"
+					buffer.puts "- Markdown: #{@options[:markdown]} | Index: #{@options[:index]} | Directory Listing: #{@options[:directory_listing]}"
+				end
+				
+				Async do |task|
+					server = Luna::Server.new(middleware, endpoint, protocol: endpoint.protocol)
+					
+					server.run
+					
+					task.children.each(&:wait)
+				end
+			end
+		end
+	end
+end

data/lib/luna/command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "command/serve"
+
+module Luna
+	module Command
+		def self.call(*arguments)
+			Serve.call(*arguments)
+		end
+	end
+end

data/lib/luna/middleware/markdown.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "protocol/http/middleware"
+
+begin
+	require "markly"
+rescue LoadError
+	# The gemspec declares dependency, but handle gracefully if not present at runtime.
+end
+
+module Luna
+	module Middleware
+		# Render Markdown files to HTML on-the-fly.
+		# Intercepts requests that target .md/.markdown files.
+		class Markdown < Protocol::HTTP::Middleware
+			def initialize(app, root: Dir.pwd, index_candidates: ["index.md", "README.md"]) 
+				super(app)
+				@root = File.expand_path(root)
+				@index_candidates = index_candidates
+			end
+			
+			attr :root
+			attr :index_candidates
+			
+			def safe_join(path)
+				full = File.expand_path(File.join(@root, path))
+				return nil unless full.start_with?(@root)
+				full
+			end
+			
+			def call(request)
+				return super unless request.method == "GET" || request.method == "HEAD"
+				path = request.path.split("?", 2).first
+				
+				fs_path = safe_join(path)
+				return super unless fs_path
+				
+				if File.directory?(fs_path)
+					candidate = @index_candidates.map {|n| File.join(fs_path, n)}.find {|p| File.file?(p)}
+					return render_file(candidate, head: request.method == "HEAD") if candidate
+				elsif File.file?(fs_path) && markdown_file?(fs_path)
+					return render_file(fs_path, head: request.method == "HEAD")
+				end
+				
+				super
+			end
+			
+			private
+			
+			def markdown_file?(path)
+				[".md", ".markdown"].include?(File.extname(path).downcase)
+			end
+			
+			def render_html(markdown)
+				if defined?(::Markly)
+					::Markly.render_html(markdown)
+				else
+					# Fallback minimal rendering if markly isn't available:
+					escape = ->(s){s.to_s.gsub("&","&amp;").gsub("<","&lt;").gsub(">","&gt;")}
+					"<pre>" + escape.call(markdown) + "</pre>"
+				end
+			end
+			
+			def render_file(path, head: false)
+				content = File.read(path)
+				html = render_html(content)
+				headers = [
+						["content-type", "text/html; charset=utf-8"]
+					]
+				Protocol::HTTP::Response[200, headers, head ? nil : [html]]
+			end
+		end
+	end
+end

data/lib/luna/middleware/static.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "protocol/http/middleware"
+require "protocol/http/body/file"
+require "time"
+
+module Luna
+	module Middleware
+		# Serve static files from a root directory, with optional index and directory listing.
+		class Static < Protocol::HTTP::Middleware
+			MIME_TYPES = {
+				".html" => "text/html; charset=utf-8",
+				".css" => "text/css",
+				".js" => "application/javascript",
+				".json" => "application/json",
+				".xml" => "application/xml",
+				".txt" => "text/plain; charset=utf-8",
+				".md" => "text/markdown; charset=utf-8",
+				".png" => "image/png",
+				".jpg" => "image/jpeg",
+				".jpeg" => "image/jpeg",
+				".gif" => "image/gif",
+				".svg" => "image/svg+xml",
+				".ico" => "image/x-icon",
+				".pdf" => "application/pdf",
+				".zip" => "application/zip",
+			}.freeze
+			
+			def initialize(app, root: Dir.pwd, index: "index.html", directory_listing: true)
+				super(app)
+				@root = File.expand_path(root)
+				@index = index
+				@directory_listing = directory_listing
+			end
+			
+			attr :root
+			attr :index
+			attr :directory_listing
+			
+			def mime_type_for_extension(ext)
+				MIME_TYPES[ext.downcase] || "application/octet-stream"
+			end
+			
+			def safe_join(path)
+				full = File.expand_path(File.join(@root, path))
+				return nil unless full.start_with?(@root)
+				full
+			end
+			
+			def call(request)
+				return super unless request.method == "GET" || request.method == "HEAD"
+				# Remove query and decode percent-encoding carefully:
+				request_path = request.path.split("?", 2).first
+				
+				file_path = safe_join(request_path)
+				return super unless file_path
+				
+				if File.exist?(file_path)
+					if File.directory?(file_path)
+						index_path = File.join(file_path, @index)
+						if File.file?(index_path)
+							return serve_file(index_path, head: request.method == "HEAD")
+						elsif @directory_listing
+							return serve_directory_listing(file_path, request_path)
+						else
+							return super
+						end
+					elsif File.file?(file_path)
+						return serve_file(file_path, head: request.method == "HEAD")
+					end
+				end
+				
+				super
+			end
+			
+			private
+			
+			def serve_file(path, head: false)
+				stat = File.stat(path)
+				headers = [
+						["content-type", mime_type_for_extension(File.extname(path))],
+						["last-modified", stat.mtime.httpdate],
+					]
+				
+				body = head ? nil : Protocol::HTTP::Body::File.open(path)
+				
+				Protocol::HTTP::Response[200, headers, body]
+			end
+			
+			def serve_directory_listing(dir_path, request_path)
+				entries = Dir.entries(dir_path).sort - ["."]
+				entries.reject! {|e| e == ".."} if request_path == "/"
+				links = entries.map do |e|
+					name = e
+					target = File.join(request_path, e)
+					target += "/" if File.directory?(File.join(dir_path, e)) && !target.end_with?("/")
+					"<li><a href=\"#{escape_html(target)}\">#{escape_html(name)}</a></li>"
+				end.join("\n")
+				html = <<~HTML
+				<!doctype html>
+				<meta charset="utf-8">
+				<title>Index of #{escape_html(request_path)}</title>
+				<h1>Index of #{escape_html(request_path)}</h1>
+				<ul>#{links}</ul>
+			HTML
+				
+				headers = [
+						["content-type", "text/html; charset=utf-8"]
+					]
+				
+				Protocol::HTTP::Response[200, headers, [html]]
+			end
+			
+			def escape_html(s)
+				s.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+			end
+		end
+	end
+end

data/lib/luna/middleware/verbose.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "console"
+require "async/http/statistics"
+
+module Luna
+	module Middleware
+		# Simple HTTP logging middleware adapted from Falcon.
+		class Verbose < Protocol::HTTP::Middleware
+			def initialize(app, logger = Console)
+				super(app)
+				@logger = logger
+			end
+			
+			def annotate(request)
+				task = Async::Task.current
+				address = request.remote_address
+				@logger.info(request, "-> #{request.method} #{request.path}", headers: request.headers.to_h, address: address.inspect)
+				task.annotate("#{request.method} #{request.path} from #{address.inspect}")
+			end
+			
+			def call(request)
+				annotate(request)
+				statistics = Async::HTTP::Statistics.start
+				response = super
+				statistics.wrap(response) do |body, error|
+					@logger.info(request, "<- #{request.method} #{request.path}", headers: response.headers.to_h, status: response.status, body: body.inspect, error: error)
+				end
+				response
+			end
+		end
+	end
+end

data/lib/luna/server.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "async/http/server"
+require "protocol/http/middleware/builder"
+require "protocol/http/content_encoding"
+
+require_relative "middleware/verbose"
+require_relative "middleware/static"
+require_relative "middleware/markdown"
+
+module Luna
+	# HTTP server hosting a middleware stack for static content.
+	class Server < Async::HTTP::Server
+		# Build a middleware for serving static files with optional markdown and logging.
+		# @param root [String] Root directory for content.
+		# @param verbose [Boolean] Enable verbose logging.
+		# @param markdown [Boolean] Enable markdown rendering.
+		# @param index [String] Index file for directories.
+		# @param directory_listing [Boolean] Enable basic directory listing when no index exists.
+		def self.middleware(root: Dir.pwd, verbose: false, markdown: true, index: "index.html", directory_listing: true)
+			::Protocol::HTTP::Middleware.build do
+				use Luna::Middleware::Verbose if verbose
+				use ::Protocol::HTTP::ContentEncoding
+				use Luna::Middleware::Markdown, root: root if markdown
+				run Luna::Middleware::Static.new(
+					->(request){Protocol::HTTP::Response[404, {"content-type"=>"text/plain"}, ["Not Found"]]},
+					root: root,
+					index: index,
+					directory_listing: directory_listing
+				)
+			end
+		end
+	end
+end

data/lib/luna/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Luna
+	VERSION = "0.0.1"
+end

data/lib/luna.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "luna/version"
+
+module Luna
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2025, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,52 @@
+# Luna
+
+A tiny, asynchronous static file server with optional Markdown rendering, built on Protocol::HTTP and Async.
+
+  - Static files via `Luna::Middleware::Static`
+  - Optional Markdown-to-HTML via `Luna::Middleware::Markdown` (using `markly`)
+  - Simple verbose logging via `Luna::Middleware::Verbose`
+
+[![Development Status](https://github.com/socketry/luna/workflows/Test/badge.svg)](https://github.com/socketry/luna/actions?workflow=Test)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "luna"
+
+And then execute:
+
+    bundle install
+
+Or install it yourself as:
+
+    gem install luna
+
+## Usage
+
+Serve the current directory:
+
+    luna --bind http://localhost:3000
+
+Options:
+
+  - `--root PATH` (default: current directory)
+  - `--index FILENAME` (default: `index.html`)
+  - `--[no]-directory-listing` (default: `true`)
+  - `--[no]-markdown` (default: `true`)
+  - `--[no]-verbose`
+  - `--bind URL` (default: `http://localhost:3000`)
+
+## Programmatic Usage
+
+    require "async"
+    require "async/http/endpoint"
+    require "luna/server"
+    
+    endpoint = Async::HTTP::Endpoint.parse("http://localhost:3000")
+    app = Luna::Server.middleware(root: "/path/to/root", markdown: true)
+    
+    Async do |task|
+      server = Luna::Server.new(app, endpoint, protocol: endpoint.protocol)
+      server.run
+    end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: luna
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.75'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.75'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.30'
+- !ruby/object:Gem::Dependency
+  name: markly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+- !ruby/object:Gem::Dependency
+  name: samovar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+executables:
+- luna
+extensions: []
+extra_rdoc_files: []
+files:
+- agents.md
+- bin/luna
+- examples/static/README.md
+- examples/static/index.html
+- lib/luna.rb
+- lib/luna/command.rb
+- lib/luna/command/serve.rb
+- lib/luna/middleware/markdown.rb
+- lib/luna/middleware/static.rb
+- lib/luna/middleware/verbose.rb
+- lib/luna/server.rb
+- lib/luna/version.rb
+- license.md
+- readme.md
+homepage: https://github.com/socketry/luna
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/socketry/luna.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: A tiny, asynchronous static file server with optional Markdown rendering.
+test_files: []