koi-server 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ae15672990b7868474ae97997cb5938dfdc0bae534de6568749aad8ad1f111f
+  data.tar.gz: 3889154d8e5bf470942ef2af98657c3c4cf7b24561c8a11428b903c3108ad692
+SHA512:
+  metadata.gz: 31e9220a59089665ec0bcdd807ab2b87ddd749e3e52b9ba818e6f5ef564a4bd940ad4f4520e000638670d2419f4d5445d8e8bf67423d79f40e33714589ff6224
+  data.tar.gz: 044e02890146c4c86aa7b397b14d79acf3bcf9398f38cf61d5566ad473a3b99a78f3ecccc086b1a7e2017de1697da8500d4a9c1d6484f9bc8ba02b19ecf1c62f

data/.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = 'koi-server'
+  s.version     = '1.0.0'
+  s.licenses    = ['MIT']
+  s.summary     = "Koi is a ruby-based Gemini server that supports ERB templating."
+  s.description = "Koi is a ruby-based Gemini server that supports .erb templating, and static files, and handles TLS certs for you.
+
+Koi is designed to make hosting Gemini CGI pages a joyful and
+tranquil experience, uniting the conceptual beauty of a simple web
+with developer happiness.
+
+By using a combination of Ruby powered ERB templating and
+traditional static file serving we distill a solution offering
+the best of both worlds.
+"
+  s.authors     = ["Justin Woodring"]
+  s.email       = 'jwoodrg@gmail.com'
+  s.files       = `git ls-files -z`.split("\x0")
+  s.executables << "koi"
+  s.homepage    = 'https://rubygems.org/gems/koi'
+  s.metadata    = { "source_code_uri" => "https://github.com/JustinWoodring/Koi" }
+end

data/.gitignore

@@ -0,0 +1,2 @@
+*~
+.DS_Store

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# gem "rails"

data/README.org

@@ -0,0 +1,103 @@
+#+title: Koi Gemini Server
+#+subtitle: A Gemini server that serves templated static .erb files.
+#+author: Justin Woodring
+#+language: en
+
+Koi is another ruby-based Gemini server that supports .erb templating,
+and static files, and handles TLS certs for you.
+
+* Ethos
+
+Koi is designed to make hosting Gemini CGI pages a joyful and
+tranquil experience, uniting the conceptual beauty of a simple web
+with developer happiness.
+
+By using a combination of Ruby powered ERB templating and
+traditional static file serving we distill a solution offering
+the best of both worlds.
+
+* How it works
+
+This server operates in every capacity as a static file server,
+unless the file it is serving begins with . i.e. hidden files or
+the file ends a .erb extension.
+
+Files ending with a .erb extension use the ERB markup syntax to
+generate responses that are assumed to be `gemtext`, under most
+circumstances. That said, each file is executed with it's directory
+as the PWD and it injects binds the following into the ERB environment:
+
+** Request: Object = Gemini Request Received
+*** protocol: String - should always be 'gemini://'
+*** domain: String - the domain name in the absolute URI
+*** path: String - absolute file path relative to served root
+*** query: String - what follows ? in the absolute URI (url_encoded)
+
+** response_status: Integer = nil
+These object can be set to override default gemtext generation. This
+particular property changes the response code with the raw Gemini code
+for a given response e.g. 10 is input required.
+
+** response_metadata: String = nil
+This is the metadata object of the response that can be overridden to
+supply supplementary info for a given response. e.g. a redirect URL,
+a new content type header, a query description text.
+
+** response_content: String = nil
+This can be used to return arbitrary content and overrides what .erb
+evaluates to if set. You could theoretically generate and serve images
+from an .erb by setting this property with the correct mime type
+set in the metadata.
+
+Here is a contrived example that demonstates the power of ERB templating
+in this context:
+
+#+NAME: /posts/index.erb
+#+BEGIN_SRC erb
+# Search my posts
+
+<% if request.query == "" %>
+   <% @response_status = 10 %>
+   <% @response_metadata = "Enter a filter term" %>
+<% end %>
+
+<% `ls`.split("\n").select {|x| x.start_with?(@request.query) and x.end_with?(".gmi")}.each do |item| %>
+    => gemini://mysite.com/posts/<%= item %>
+<% end %>
+#+END_SRC
+
+* Running Your Own Server
+
+Running your own server is as simple as installing one gem: `koi`
+and pointing it at a cert and key that you might even generate
+using `koi`.
+
+#+begin_example
+
+# Defaults are -s nil -b 0.0.0.0 -p 1965 -e (.erb enabled)
+
+koi -s /home/user/public_gmi
+
+OR
+
+koi -s /home/user/public_gmi -b 0.0.0.0 -p 1965
+
+OR
+
+koi -s /home/user/public_gmi -b 0.0.0.0 -p 1965 --no-erb
+
+OR
+
+koi -s /home/user/public_gmi -b 0.0.0.0 -p 1965 -e -k key.pem -c cert.pem
+
+FOR CERTIFICATE GENERATION
+
+koi -g COMMONNAME
+#+end_example
+
+
+* No AI Notice
+
+No AI tools were used at any point during developemnt or
+documentation. This project was expressly 100% hand-written
+by a human.

data/bin/koi

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../lib/koi.rb'
+
+# Declare defaults
+config = {
+  bind_addr: "0.0.0.0", # Bind All Available Interfaces  
+  bind_port: "1965", # Default Gemini Port
+  file_root_dir: nil, # No Default  
+  erb_enabled: true # Assume Yes
+  key_file_path: nil
+  cert_file_path: nil
+}
+
+
+# Declare parse options
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage:\tkoi [options]\n\tkoi -s ~/public_gmi -b '0.0.0.0' -p 1965 -e true"
+
+  opts.separator ""
+  opts.separator "Specific options:"
+  
+  opts.on("-s", "--serve FILE_ROOT", String, "Required. File root of public .gmi and .erb files") do |v|
+    config[:file_root_dir] = v 
+  end
+  
+  opts.on("-b", "--bind_addr ADDR", String, "Bind address for the server to listen on") do |v|
+    config[:bind_addr] = v 
+  end
+
+  opts.on("-p", "--port PORT", Integer, "Bind port for the server to listen on") do |v|
+    config[:bind_port] = v 
+  end
+  
+  opts.on("-e", "--[no]-erb", "Enable serving .erb files") do |v|
+    config[:erb_enabled] = v 
+  end
+
+  opts.separator "Certificate options, if either is unset the server will generate a throwaway self-signed cert on-demand."
+  
+  opts.on("-k", "--key KEY_FILE_PATH", String, "Path to your private key.") do |v|
+    config[:key_file_path] = v 
+  end
+
+  opts.on("-c", "--cert CERT_FILE_PATH", String, "Path to your certificate.") do |v|
+    config[:cert_file_path] = v 
+  end
+  
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-g", "--generate-cert CN", "Generate a self-signed certficate") do |cn|
+    key, cert = Koi::SSL.generate_key_and_cert(cn)
+    File.write('koi_private_key.pem', key.to_pem)
+    File.write('koi_certificate.pem', cert.to_pem)
+
+    puts "Key written to koi_private_key.pem successfully!"
+    puts "Key written to koi_certificate.pem successfully!"
+    exit
+  end
+    
+  opts.on_tail("-h", "--help", "Prints this help") do
+    puts parser
+    exit
+  end
+end
+
+# Parse output and validate required fields.
+puts parser.parse!(ARGV)
+
+if config[:file_root_dir] == nil then
+  puts parser
+  exit
+end
+
+# Run the Koi server!
+
+koi = Koi::Pond.new(config)
+koi.run
+
+
+
+
+  
+

data/lib/koi/erb/handler.rb

@@ -0,0 +1,118 @@
+require 'erb'
+require 'open3'
+
+require_relative '../gemini'
+
+class Koi::ERB::Handler
+  def initialize
+    # We might put properties that can defined here in the future.
+  end
+
+  def handler_internal(filename, request)
+    ruby_code = <<~RUBY
+           require 'erb'
+
+           class Koi
+           end
+
+           class Koi::ERB
+           end
+
+           class Koi::ERB::Context
+                 @request = nil
+                 @response_status = nil
+                 @response_metadata = nil
+                 @response_content = nil
+  
+                 attr_accessor :request, :response_status, :response_metadata, :response_content
+
+                 def initialize(request)
+                     @request = request
+                     @response_status = nil
+                     @response_metadata = nil
+                     @response_content = nil
+                 end
+    
+                 def get_binding
+                     return binding
+                 end
+           end
+
+           class Koi::Gemini
+           end
+
+           class Koi::Gemini::Request
+                 attr_accessor :is_valid, :protocol, :domain, :path, :query
+
+                 def initialize(is_valid, protocol, domain, path, query)
+                     @is_valid = is_valid
+                     @protocol = protocol
+                     @domain = domain
+                     @path = path
+                     @query = query
+                 end
+           end
+
+           request = Koi::Gemini::Request.new(
+                   "#{request.is_valid}",
+                   '#{request.protocol.to_s.dump}'.undump,
+                   '#{request.domain.to_s.dump}'.undump,
+                   '#{request.path.to_s.dump}'.undump,
+                   '#{request.query.to_s.dump}'.undump)
+
+           template_content = File.binread('#{filename.dump}'.undump)
+           context = Koi::ERB::Context.new(request)
+           erb = ERB.new(template_content)
+
+           output = erb.result(context.get_binding)
+
+           status = if context.response_status != nil
+                  context.response_status else 20 end
+           metadata = if context.response_metadata != nil
+                  context.response_metadata else
+                   "text/gemini; charset=utf-8" end
+           content = if context.response_content != nil
+                  context.response_content else
+                  output.b end
+
+           puts status
+           puts metadata
+           puts content
+RUBY
+
+    return ruby_code
+  end  
+  
+  def handle(valid_path, request)
+    begin
+      # Initialize ERB
+      filename = valid_path[valid_path.rindex('/')+1..-1]
+      path_prefix = valid_path[0..valid_path.rindex('/')]
+      
+      stdout, stderr, code = Open3.capture3("ruby",
+                                              chdir: valid_path[0..valid_path.rindex('/')],
+                                              stdin_data: handler_internal(filename, request))
+      
+      output = stdout.split("\n",3)
+
+      puts "---\n#{stdout}\n---"
+      puts "---\n#{stderr}\n---"
+      
+      status = output[0]
+      metadata = output[1]
+      content = output[2]
+    
+      return Koi::Gemini::Response.new(status, metadata, content)
+    rescue Exception => e 
+      status = Koi::Gemini::Status::PermanentGenericError
+      metadata = "CGI backend experienced an error."
+      content = nil
+
+      puts e
+
+      return Koi::Gemini::Response.new(status, metadata, content)
+    end
+  end
+end
+
+  

data/lib/koi/erb.rb

@@ -0,0 +1,6 @@
+require 'erb'
+
+class Koi::ERB
+end
+
+require_relative './erb/handler'

data/lib/koi/file.rb

@@ -0,0 +1,95 @@
+require_relative "./gemini"
+require_relative "./erb"
+
+class FileServer
+  @base_directory = nil
+  @erb_enabled = false
+  @erb_handler = nil
+
+  def initialize(base_directory, erb_enabled)
+    @base_directory = base_directory
+    @erb_enabled = erb_enabled
+    if erb_enabled then
+      @erb_handler = Koi::ERB::Handler.new
+    end
+  end
+
+  def search_path(path)
+    files = Dir.glob("#{@base_directory}/**/*").each do |f|
+      f.sub!("#{@base_directory}", "")
+    end.append("/")
+
+    f_trimmed = files.find { |file| path == file }
+
+    if f_trimmed != nil then
+      if File.directory?(File.join("#{@base_directory}", f_trimmed)) then
+        # If we are in a directory lets test for an index.erb and then index.gmi
+
+        if @erb_enabled then
+          i = File.join("#{@base_directory}", f_trimmed, "index.erb")
+
+          if File.exist?(i) then
+            return i
+          end
+        end
+
+        i = File.join("#{@base_directory}", f_trimmed, "index.gmi")
+        if File.exist?(i) then
+          return i
+        end 
+      else
+        i = File.join("#{@base_directory}", f_trimmed)
+        return i
+      end
+    end
+
+    return nil
+  end
+
+  def route(request)
+    valid_path = search_path(request.path)
+
+    if valid_path != nil then
+      if valid_path.end_with?(".erb") and not @erb_enabled then
+        # Filter a file ending in .erb if .erb is not enabled. If the path ends with this return Not Found.
+        return Koi::Gemini::Response.new(Koi::Gemini::Status::NotFound, "Resource Not Found", nil)
+      elsif valid_path.split("/")[-1].start_with?(".") then
+        # Check for files beginning with . and ignore them.
+
+        # If the file begins with . as in .env then return Not Found.
+        return Koi::Gemini::Response.new(Koi::Gemini::Status::NotFound, "Resource Not Found", nil)
+      else
+        # Consider the route safe, figure out how to pack the response.
+        if valid_path.end_with?(".erb")
+          response = @erb_handler.handle(valid_path, request)
+          return response
+        else
+          status = Koi::Gemini::Status::Success
+          metadata = if valid_path.end_with?(".gmi")
+                       "text/gemini; charset=utf-8"
+                     elsif valid_path.end_with?(".txt")
+                       "text/plain; charset=utf-8"
+                     elsif valid_path.end_with?(".zip")
+                       "application/zip"
+                     elsif valid_path.end_with?(".pdf")
+                       "application/pdf"
+                     elsif valid_path.end_with?(".gif")
+                       "image/gif"
+                     elsif valid_path.end_with?(".jpeg", ".jpg")
+                       "image/jpeg"
+                     elsif valid_path.end_with?(".png")
+                       "image/png"
+                     else
+                       "application/octet-stream"
+                     end
+                       
+          content = File.binread(valid_path)
+          return response = Koi::Gemini::Response.new(status, metadata, content)
+        end
+      end
+    else
+      # No File Found
+      return Koi::Gemini::Response.new(Koi::Gemini::Status::NotFound, "Resource Not Found", nil)
+    end
+  end
+end

data/lib/koi/gemini/request.rb

@@ -0,0 +1,60 @@
+class Koi::Gemini::Request
+  @is_valid = true
+  
+  attr_accessor :is_valid, :protocol, :domain, :path, :query 
+
+  def self.parse(input)
+    if self.is_a?(Class)
+     req = Koi::Gemini::Request.allocate
+
+     if input[0...9] == "gemini://" then
+       req.protocol = "gemini://"
+     end
+
+     domain_path_query = input[9..-1].gsub('\r\n','').strip
+     split = domain_path_query.split("/",2)
+
+     if split[0] != nil
+       and not split[0].include?("/")
+       and not split[0].include?('"')
+       and not split[0].include?("'")
+       and not split[0].include?(" ") then
+
+       req.domain = split[0]
+       req.path = "/index"
+       req.query = ""
+       req.is_valid = true
+       else
+       req.is_valid = false
+     end
+
+     if split[1] != nil
+       if not split[1].include?("..")
+         and not split[1].include?(" ")
+         and not split[1].include?("'")
+         and not split[1].include?('"') then
+         if split[1].include?("?") then
+           path_query = split[1].split("?")
+           req.path = "/"+path_query[0]
+           req.query = path_query[1]
+         else
+           req.path = "/"+split[1]
+         end
+       else 
+         req.is_valid = false
+       end
+     end
+
+     return req
+    end
+    raise "This method should be called from the class, not an instance!"
+  end
+
+  def is_valid?
+    if self.is_a?(Class)
+      raise "This method must be called on an instance, not the class!"
+    end
+
+    return @is_valid
+  end
+end

data/lib/koi/gemini/response.rb

@@ -0,0 +1,15 @@
+require_relative './status'
+
+class Koi::Gemini::Response
+  attr_accessor :status, :metadata, :content
+  
+  def initialize(status, metadata, content)
+    @status = status
+    @metadata = metadata
+    @content = content
+  end
+
+  def to_s
+    return "#{@status} #{metadata}\r\n#{@content}".b
+  end
+end

data/lib/koi/gemini/status.rb

@@ -0,0 +1,31 @@
+module Koi::Gemini::Status
+  #1X
+  InputExpected = 10
+  InputExpectedSensitive = 11
+
+  #2X
+  Success = 20
+
+  #3X
+  TemporaryRedirection = 30
+  PermanentRedirection = 31
+
+  #4X
+  RetryableGenericError = 40
+  RetryableServerUnavailableError = 41
+  RetryableCGIError = 42
+  RetryableProxyError = 43
+  RetryableSlowDownError = 44
+
+  #5X
+  PermanentGenericError = 50
+  NotFound = 51
+  Gone = 52
+  ProxyRequestRefused = 53
+  BadRequest = 59
+
+  #60
+  NeedClientCertificate = 60
+  CertificateNotAuthorized = 61
+  CertificateNotValid = 62
+end

data/lib/koi/gemini.rb

@@ -0,0 +1,6 @@
+class Koi::Gemini
+end
+
+require_relative './gemini/status'
+require_relative './gemini/request'
+require_relative './gemini/response'

data/lib/koi/server.rb

@@ -0,0 +1,91 @@
+require 'socket'
+require 'openssl'
+require_relative './gemini'
+require_relative './ssl'
+require_relative './file'
+
+class Koi::Server
+  @config = {}
+  @file_server = nil
+  
+  def initialize(config)
+    @config = config
+    @file_server = FileServer.new(@config[:file_root_dir], @config[:erb_enabled])
+  end
+
+  def run
+    # Spawn TCP listener.
+    server = TCPServer.new(@config[:bind_addr], @config[:bind_port])
+
+    puts "                                                                      
+                                                                      
+                                  :.                                  
+                                  :xx                                 
+                                 .;+x  +;+:                           
+                        .x   +&;;;;;;;+;;;+;:;;X        :.:.          
+                          ::::+&&;::::::::::::::$+     ..:..;         
+                      ;xx::::::::::;;::::::...::+      :;:.;;         
+                    ;;::::::::;+xxxxx;::.:..         x+;+Xxx          
+                   +$::..:;        .::                &$$$X;x         
+                  ++;:                                &&&$$x          
+                 :x:               +.                 &$$$x           
+                 +                ;;.                $$XX             
+                ;;      XXx$$&X;;&+X$&       ;:    :X&$               
+               ++;    ++x::::::::x+&&&$$$Xxxx::::::;                  
+              +;+;;   ++;:X:::::;$:;:XXXx:::xxX+xxxx;                 
+              :;;;:;.     .::+X$;:$$$X+::::::x                        
+             :;;:;;:           :.     x.+                             
+             .:..:.            .       X:;                            
+             .  .                       +++                           
+                                          ::                          
+                                                                      
+          
+                                                                      "
+    puts "Koi Gemini Server - #{Koi::VERSION} - Listening on #{@config[:bind_addr]}:#{@config[:bind_port]}."
+    
+    # Define SSL context
+    
+    ctx = if @config[:key_file_path] == nil or
+            @config[:cert_file_path] == nil then
+            Koi::SSL.generate_debug_ctx
+          else
+            Koi::SSL.generate_ctx_from_files(@config[:key_file_path], @config[:cert_file_path])
+          end
+      
+    # Loop TCP connections with Thread pool.
+    loop do
+      Thread.start(server.accept) do |socket|
+        begin
+          # Begin client upgrade
+          client = OpenSSL::SSL::SSLSocket.new(socket, ctx)
+          client.accept
+
+          # Client stable begin server request handling
+          handle(client)
+            
+        rescue OpenSSL::SSL::SSLError
+          puts "Failed to upgrade client connection to SSL."
+        ensure
+          ssl_socket.close rescue nil
+          socket.close rescue nil
+        end
+      end
+    end
+  end
+
+  def handle(client)
+    request = Koi::Gemini::Request.parse(client.gets)
+
+    if not request.is_valid? then
+      resp = Koi::Gemini::Response.new(Koi::Gemini::Status::BadRequest)
+
+      puts "#{resp.status}: #{request.protocol}#{request.domain}#{request.path}" + (request.query != "" ? "?#{request.query}" : "")
+      client.send(resp.to_s)
+    else
+      resp = @file_server.route(request)
+
+      puts "#{resp.status}: #{request.protocol}#{request.domain}#{request.path}" + (request.query != "" ? "?#{request.query}" : "")
+      client.write(resp.to_s)
+    end
+  end
+end

data/lib/koi/ssl.rb

@@ -0,0 +1,67 @@
+require 'openssl'
+
+class Koi::SSL
+  
+  def self.generate_debug_ctx
+    ctx = OpenSSL::SSL::SSLContext.new
+
+    ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+    ctx.max_version = OpenSSL::SSL::TLS1_3_VERSION
+
+    ctx.key = generate_private_key
+    ctx.cert = generate_and_sign_cert(ctx.key, "localhost")
+    
+    return ctx 
+  end
+
+  def self.generate_ctx_from_files(key_path, cert_path)
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+    ctx.max_version = OpenSSL::SSL::TLS1_3_VERSION
+
+    # Load private key.
+    key_data = File.read(key_path)
+    private_key = OpenSSL::PKey.read(key_data, nil)
+
+    # Load the X509 certificate
+    cert_data = File.read(cert_path)
+    cert = OpenSSL::X509::Certificate.new(cert_data)
+
+    # Verify that the private key matches the certificate
+    if cert.check_private_key(private_key)
+      raise "Error: Private key does not match the certificate!"
+    end
+
+    ctx.key = private_key
+    ctx.cert = cert
+    return ctx
+  end
+  
+
+  def self.generate_key_and_cert(cn)
+    key = generate_private_key
+    cert = generate_and_sign_cert(key, cn)
+
+    return key, cert
+  end
+
+  def self.generate_private_key
+    key = OpenSSL::PKey::RSA.new(2048)
+    return key
+  end
+
+  def self.generate_and_sign_cert(key, cn)
+    cert = OpenSSL::X509::Certificate.new
+    cert.version = 2
+    cert.serial = 1
+    cert.subject = OpenSSL::X509::Name.new([['CN', cn]])
+    cert.issuer = cert.subject
+    cert.public_key = key.public_key
+    cert.not_before = Time.now
+    cert.not_after = Time.now + (60 * 60 * 24 * 365)
+
+    cert.sign(key, OpenSSL::Digest::SHA256.new)
+
+    return cert
+  end
+end

data/lib/koi.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Koi
+  VERSION = "1.0.0"
+end
+
+require_relative './koi/server'
+
+module Koi
+  class Pond 
+    def initialize(config)
+      @config = config
+    end
+
+    def run
+      server = Koi::Server.new(@config)
+      server.run
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: koi-server
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Justin Woodring
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Koi is a ruby-based Gemini server that supports .erb templating, and static files, and handles TLS certs for you.
+
+  Koi is designed to make hosting Gemini CGI pages a joyful and
+  tranquil experience, uniting the conceptual beauty of a simple web
+  with developer happiness.
+
+  By using a combination of Ruby powered ERB templating and
+  traditional static file serving we distill a solution offering
+  the best of both worlds.
+email: jwoodrg@gmail.com
+executables:
+- koi
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gemspec"
+- ".gitignore"
+- Gemfile
+- README.org
+- bin/koi
+- lib/koi.rb
+- lib/koi/erb.rb
+- lib/koi/erb/handler.rb
+- lib/koi/file.rb
+- lib/koi/gemini.rb
+- lib/koi/gemini/request.rb
+- lib/koi/gemini/response.rb
+- lib/koi/gemini/status.rb
+- lib/koi/server.rb
+- lib/koi/ssl.rb
+homepage: https://rubygems.org/gems/koi
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/JustinWoodring/Koi
+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: 4.0.11
+specification_version: 4
+summary: Koi is a ruby-based Gemini server that supports ERB templating.
+test_files: []