gemini_server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29f2c81f5db11cffa8974cf4a1a48654ac00565b66f2ce306086f900246b34f9
+  data.tar.gz: 842fee3d9d59845cc851b65c2dc918a4ee850e5ffd6f27e4b1c09131a1181659
+SHA512:
+  metadata.gz: 62be452faaec4d6c4b59a15f3847f6776f795a57d7037ec7ff54452ba15ec1ad3410e645e0c595c2358dd53ff0da54410765be27e6448f3519cc5c0ebb857edb
+  data.tar.gz: 1cce37852838f92ced3fb4e504ff4356d0d098ef27a47d6638d6cb0123b4d2b8c8a63a0412260c15c71da9c78ab37df8f267328e9c331c3d5643614e95510cbe

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock
+*.py
+ssl

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gemini_server.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/README.md

@@ -0,0 +1,144 @@
+# GeminiServer
+
+A simple server for the Gemini protocol, with an API inspired by Sinatra.
+
+## Usage
+
+```ruby
+require "gemini_server"
+
+server = GeminiServer.new
+
+server.route("/hithere/:friend") do
+  if params["friend"] == "Gary"
+    gone "Gary and I aren't on speaking terms, sorry."
+  else
+    success "Hi there, #{params["friend"]}!"
+  end
+end
+
+server.route("/byebye") do
+  lang "pig-latin"
+  success "arewellfay!"
+end
+
+server.listen("0.0.0.0", 1965)
+```
+
+### Initialization options
+
+<dl>
+  <dt><code>cert</code>*</dt>
+  <dd>A SSL certificate. Either a <code>OpenSSL::X509::Certificate</code> object, or a string.</dd>
+  <dt><code>cert_path</code>*</dt>
+  <dd>Path to a SSL certificate file. Defaults to the value of the env variable <code>GEMINI_CERT_PATH</code>. Ignored if <code>cert</code> option is supplied.</dd>
+  <dt><code>key</code>*</dt>
+  <dd>A SSL key. Either a <code>OpenSSL::PKey</code> object, or a string.</dd>
+  <dt><code>key_path</code>*</dt>
+  <dd>Path to a private key file. Defaults to the value of the env variable <code>GEMINI_KEY_PATH</code>. Ignored if <code>key</code> option is supplied.</dd>
+  <dt><code>mime_type</code></dt>
+  <dd>Sets the default MIME type for successful responses. Defaults to <code>text/gemini</code>, or inferred by the name of the file being served.</dd>
+  <dt><code>charset</code></dt>
+  <dd>If set, includes the charset in the response's MIME type.</dd>
+  <dt><code>lang</code></dt>
+  <dd>If set, includes the language in the response's MIME type, if the MIME type is <code>text/gemini</code>. Per the Gemini spec, <em>"Valid values for the "lang" parameter are comma-separated lists of one or more language tags as defined in RFC4646."</em></dd>
+  <dt><code>public_folder</code></dt>
+  <dd>Path to a location from which the server will serve static files. If not set, the server will not serve any static files.</dd>
+  <dt><code>views_folder</code></dt>
+  <dd>Path to the location of ERB templates. If not set, defaults to current directory.</dd>
+</dl>
+
+*\* The option pairs `cert` and `cert_path`, and likewise `key` and `key_path`, are mutually exclusive, so they are technically optional. But per the Gemini spec, connections must use TLS, so it is a runtime error if neither option, nor either of the fallback env variables, are used.*
+
+### Route handlers
+
+To define a route handler, use `GeminiServer#route`:
+
+```ruby
+server = GeminiServer.new
+server.route("/path/to/route/:variable") do
+  # route logic
+end
+```
+
+The route method takes a [Mustermann](https://github.com/sinatra/mustermann) matcher string and a block.
+
+Within the block, code has access to these methods:
+
+<dl>
+  <dt><code>params</code></dt>
+  <dd>Returns a hash of params parsed from the request path.</dd>
+  <dt><code>uri</code></dt>
+  <dd>Returns the full URI of the request.</dd>
+  <dt><code>mime_type(type)</code></dt>
+  <dd>Sets the MIME type of the response.</dd>
+  <dt><code>charset(ch)</code></dt>
+  <dd>Sets the charset of the response, overriding the server's default charset.</dd>
+  <dt><code>lang(l)</code></dt>
+  <dd>Sets the lang of the response, overriding the server's default lang.</dd>
+  <dt><code>erb(filename, locals: {})</code></dt>
+  <dd>Renders an ERB template located at <code>filename</code>, then sets status to success. MIME type is inferred by the template extension. The template will have access to any instance variables defined in the handler block, as well as any local variables passed in via the <code>locals</code> keyword param.</dd>
+  <dt><code>respond(code, meta, body=nil)</code></dt>
+  <dd>Sets the response code, meta, and optional body. It's probably easier to use <code>erb</code> method, or any of the convenience status methods in the next section.</dd>
+</dl>
+
+### ERB templates
+
+Using an ERB template automatically sets the status to `20` (success) because a success is the only type of response that can contain a body. It also tries to infer the MIME type from the template extension (excluding any `.erb`).
+
+ERB rendering can define local variables, like in Sinatra:
+
+```ruby
+server.route("/hithere/:friend") do
+  erb "hithere.gmi", locals: { friend: params["friend"] }
+end
+```
+
+```markdown
+<!-- hithere.gmi.erb -->
+# Hi there!
+
+Hi there, <%= friend %>.
+```
+
+ERB templates have the `params` hash available as a local var:
+
+```ruby
+server.route("/hithere/:friend") do
+  erb "hithere.gmi"
+end
+```
+
+```markdown
+<!-- hithere.gmi.erb -->
+# Hi there!
+
+Hi there, <%= params["friend"] %>.
+```
+
+### Status methods
+
+Each of these methods are available within a route handler block. Forgetting to use a status method defaults to a temporary failure. See [Gemini Specification](https://gemini.circumlunar.space/docs/specification.html) for an explanation of each response status.
+
+* `input(prompt)`
+* `sensitive_input(prompt)`
+* `success(body, mime_type=nil)`
+* `redirect_temporary(url)`
+* `redirect_permanent(url)`
+* `temporary_failure(explanation = "Temporary failure")`
+* `server_unavailable(explanation = "Server unavailable")`
+* `cgi_error(explanation = "CGI error")`
+* `proxy_error(explanation = "Proxy error")`
+* `slow_down(delay)`
+* `permanent_failure(explanation = "Permanent failure")`
+* `not_found(explanation = "Not found")`
+* `gone(explanation = "Gone")`
+* `proxy_request_refused(explanation = "Proxy request refused")`
+* `bad_request(explanation = "Bad request")`
+* `client_certificate_required(explanation = "Client certificate )`
+* `certificate_not_authorized(explanation = "Certificate not )`
+* `certificate_not_valid(explanation = "Certificate not valid")`
+
+### Static file serving
+
+To serve static files, set the initialization option `public_folder` to the location of your static files. If no route handlers match a request, the server will look for a static file to serve in that location instead. If the `public_folder` option is unset, no static files will be served.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/gemini_server

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+require "gemini_server"
+require "optparse"
+
+options = {
+  port: 1965,
+  cert_path: ENV["GEMINI_CERT_PATH"],
+  key_path: ENV["GEMINI_KEY_PATH"],
+}
+
+OptionParser.new do |opts|
+  opts.on("-p PORT", "--port PORT", Integer, "Port to listen on") do |port|
+    options[:port] = port
+  end
+
+  opts.on("--cert-path PATH", String, "Path to cert file") do |path|
+    options[:cert_path] = path
+  end
+
+  opts.on("--key-path PATH", String, "Path to key file") do |path|
+    options[:key_path] = path
+  end
+
+  opts.on("--charset CHARSET", String, "Charset of text/* files") do |charset|
+    options[:charset] = charset
+  end
+
+  opts.on("--lang LANG", String, "Language of text/* files") do |lang|
+    options[:lang] = lang
+  end
+end.parse!
+
+server = GeminiServer.new(
+  public_folder: ".",
+  cert_path: options[:cert_path],
+  key_path: options[:key_path],
+  charset: options[:charset],
+  lang: options[:lang],
+)
+
+server.listen("127.0.0.1", options[:port])

data/gemini_server.gemspec

@@ -0,0 +1,46 @@
+require_relative 'lib/gemini_server/version'
+
+Gem::Specification.new do |s|
+  s.name = "gemini_server"
+  s.version = GeminiServer::VERSION
+  s.authors = ["Jess Bees"]
+  s.email = ["hi@toomanybees.com"]
+
+  s.summary = "Simple server for the Gemini protocol"
+  s.description = ""
+  s.homepage = "http://github.com/TooManyBees/gemini_server"
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["source_code_uri"] = s.homepage
+  # s.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  s.require_paths = ["lib"]
+  s.executables << 'gemini_server'
+  s.date = "2020-11-16"
+  s.licenses = ["MIT".freeze]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency("addressable", ["~> 2.7"])
+    s.add_runtime_dependency("async-io", ["~> 1.30"])
+    s.add_runtime_dependency("mime-types", ["~> 3.3"])
+    s.add_runtime_dependency("mustermann", ["~> 1.1"])
+    s.add_development_dependency("localhost", ["~> 1.1"])
+  else
+    s.add_dependency("addressable", ["~> 2.7"])
+    s.add_dependency("async-io", ["~> 1.30"])
+    s.add_dependency("mime-types", ["~> 3.3"])
+    s.add_dependency("mustermann", ["~> 1.1"])
+    s.add_dependency("localhost", ["~> 1.1"])
+  end
+end
+

data/lib/gemini_server.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "addressable/uri"
+require "async/io"
+require "async/io/stream"
+require "erb"
+require "mime/types"
+require "mustermann"
+require "openssl"
+require_relative "gemini_server/mime_types"
+require_relative "gemini_server/responses"
+
+class GeminiServer
+  def initialize options = {}
+    @routes = []
+    @public_folder = File.expand_path(options[:public_folder]) rescue nil
+    @views_folder = File.expand_path(options[:views_folder] || ".")
+    @charset = options[:charset]
+    @lang = options[:lang]
+    @ssl_cert, @ssl_key = self.load_cert_and_key(options)
+  end
+
+  def route r, &blk
+    raise "Missing required block for route #{r}" if blk.nil?
+    @routes << [Mustermann.new(r), blk]
+  end
+
+  def listen host, port
+    Async do
+      endpoint = Async::IO::Endpoint.tcp(host, port)
+      endpoint = Async::IO::SSLEndpoint.new(endpoint, ssl_context: self.ssl_context(@ssl_cert, @ssl_key))
+
+      ["INT", "TERM"].each do |signal|
+        old_handler = Signal.trap(signal) do
+          @server.stop if @server
+          old_handler.call if old_handler.respond_to?(:call)
+        end
+      end
+
+      @server = Async do |task|
+        endpoint.accept do |client|
+          start_time = clock_time
+          remote_ip = client.connect.io.remote_address.ip_address
+          io = Async::IO::Stream.new(client.connect)
+          status, size, uri, captured_error = handle_request(io, client)
+          puts log(ip: remote_ip, uri: uri, start_time: start_time, status: status, body_size: size)
+          raise captured_error if captured_error.is_a?(Exception)
+        end
+      end
+    end
+  end
+
+  private
+
+  MAX_URL_SIZE = 1024
+
+  def read_request_url io
+    buf = String.new
+    offset = 0
+    while buf.length <= MAX_URL_SIZE + 2 do
+      buf << io.read_partial
+      line_end = buf.index("\r\n", offset)
+      offset = buf.length
+      return buf[0...line_end] if line_end && line_end <= MAX_URL_SIZE
+    end
+  end
+
+  def handle_request io, client
+    data = read_request_url(io)
+    if data.nil?
+      ctx = ResponseContext.new({}, nil)
+      ctx.bad_request "URI too long"
+      return send_response(client, ctx.response)
+    end
+    status, size, captured_error = nil
+    uri = begin
+      Addressable::URI.parse(data)
+    rescue Addressable::URI::InvalidURIError
+      ctx = ResponseContext.new({}, nil)
+      ctx.bad_request "Invalid URI"
+      return send_response(client, ctx.response)
+    end
+    uri.scheme = "gemini" if uri.scheme.nil?
+    params, handler = self.find_route(uri.path)
+    if params
+      ctx = ResponseContext.new(params, uri, views_folder: @views_folder, charset: @charset, lang: @lang)
+      begin
+        ctx.instance_exec(&handler)
+      rescue StandardError => e
+        ctx.temporary_failure
+        captured_error = e
+      ensure
+        status, size = send_response(client, ctx.response)
+      end
+    elsif static_response = serve_static(uri.path)
+      status, size = send_response(client, static_response)
+    else
+      ctx = ResponseContext.new(params, uri)
+      ctx.not_found
+      status, size = send_response(client, ctx.response)
+    end
+    [status, size, uri, captured_error]
+  end
+
+  def serve_static path
+    return if @public_folder.nil?
+    path = File.expand_path "#{@public_folder}#{path}"
+    return unless path.start_with?(@public_folder)
+    File.open(path) do |f|
+      mime_type = MIME::Types.type_for(File.basename(path)).first || "text/plain"
+      { code: 20, meta: mime_type, body: f.read }
+    end
+  rescue Errno::ENOENT, Errno::ENAMETOOLONG, Errno::EISDIR # TODO: index.gmi?
+  rescue SystemCallError
+    { code: 40, meta: "Temporary failure" }
+  end
+
+  def find_route path
+    @routes.each do |(route, handler)|
+      params = route.params(path)
+      return [params, handler] if params
+    end
+    nil
+  end
+
+  def send_response client, response
+    body_size = nil
+    if (20...30).include?(response[:code])
+      mime_type = MIME::Types[response[:mime_type] || response[:meta]].first || GEMINI_MIME_TYPE
+      client.write "#{response[:code]} #{mime_type}"
+      if mime_type.media_type == "text"
+        client.write "; charset=#{response[:charset]}" if response[:charset]
+        client.write "; lang=#{response[:lang]}" if response[:lang] && mime_type.sub_type == "gemini"
+      end
+      client.write "\r\n"
+      body_size = client.write response[:body]
+    else
+      client.write "#{response[:code]} #{response[:meta]}\r\n"
+    end
+    client.close
+    [response[:code], body_size]
+  end
+
+  LOG_FORMAT = "%s - %s [%s] \"%s\" %s %s %0.4f"
+
+  def log ip:, uri:, start_time:, username:nil, status:, body_size:nil
+    # Imitates Apache common log format to the extent that it applies to Gemini
+    # http://httpd.apache.org/docs/1.3/logs.html#common
+    path = uri ? uri.omit(:scheme, :host).to_s : '<uri too long>'
+    path = path.length > 0 ? path : "/"
+    LOG_FORMAT % [ip, username || '-', Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"), path, status.to_s, body_size.to_s || '-', clock_time - start_time]
+  end
+
+  def load_cert_and_key options
+    found_cert = options[:cert] || if options[:cert_path]
+      File.open(options[:cert_path]) rescue nil
+    elsif ENV["GEMINI_CERT_PATH"]
+      File.open(ENV["GEMINI_CERT_PATH"]) rescue nil
+    end
+
+    found_key = options[:key] || if options[:key_path]
+      File.open(options[:key_path]) rescue nil
+    elsif ENV["GEMINI_KEY_PATH"]
+      File.open(ENV["GEMINI_KEY_PATH"]) rescue nil
+    end
+
+    raise "SSL certificate not found" unless found_cert
+    raise "SSL key not found" unless found_key
+
+    [
+      found_cert.is_a?(OpenSSL::X509::Certificate) ? found_cert : OpenSSL::X509::Certificate.new(found_cert),
+      found_key.is_a?(OpenSSL::PKey::PKey) ? found_key : OpenSSL::PKey.read(found_key),
+    ]
+  end
+
+  def ssl_context cert, key
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.add_certificate(cert, key)
+      context.session_id_context = "gemini_server"
+      context.min_version = OpenSSL::SSL::TLS1_2_VERSION
+      context.max_version = OpenSSL::SSL::TLS1_3_VERSION
+      context.setup
+    end
+  end
+
+  if defined?(Process::CLOCK_MONOTONIC)
+    def clock_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  else
+    def clock_time
+      Time.now.to_f
+    end
+  end
+end
+
+class ResponseContext
+  include Responses
+
+  def initialize params, uri, options={}
+    @__params = params
+    @__uri = uri
+    @__mime_type = options[:mime_type]
+    @__charset = options[:charset]
+    @__lang = options[:lang]
+    @__views_folder = options[:views_folder]
+    temporary_failure
+  end
+
+  def mime_type t
+    type = MIME::Types[t].first
+    if type
+      @__mime_type = type
+    else
+      STDERR.puts("WARN: Unknown MIME type #{t.inspect}")
+    end
+  end
+
+  def params; @__params; end
+  def uri; @__uri; end
+  def charset c; @__charset = c; end
+  def lang l; @__lang = l; end
+
+  def erb template, locals: {}
+    b = TOPLEVEL_BINDING.dup
+    b.local_variable_set(:params, params)
+    locals.each { |key, val| b.local_variable_set(key, val) }
+    template = File.basename(template.to_s, ".erb")
+    mime_type = MIME::Types.type_for(template).first || GEMINI_MIME_TYPE
+    t = ERB.new(File.read(File.join(@__views_folder, "#{template}.erb")))
+    body = t.result(b)
+    success(body, mime_type)
+  end
+
+  def respond code, meta, body=nil
+    @__response = { code: code, meta: meta, body: body }
+  end
+
+  def response
+    @__response.to_h.merge({ mime_type: @__mime_type, lang: @__lang, charset: @__charset })
+  end
+end

data/lib/gemini_server/mime_types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "mime/types"
+
+GEMINI_MIME_TYPE = MIME::Type.new({
+  "content-type" => "text/gemini",
+  "extensions" => ["gmi", "gemini"],
+  "preferred-extension" => "gemini",
+  "friendly" => "Gemtext"
+})
+
+MIME::Types.add(GEMINI_MIME_TYPE, :silent)

data/lib/gemini_server/responses.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Responses
+  def input prompt
+    respond 10, prompt
+  end
+
+  def sensitive_input prompt
+    respond 11, prompt
+  end
+
+  def success body, mime_type=nil
+    respond 20, mime_type, body
+  end
+
+  def redirect_temporary url
+    respond 30, url
+  end
+
+  def redirect_permanent url
+    respond 31, url
+  end
+
+  def temporary_failure explanation = "Temporary failure"
+    respond 40, explanation
+  end
+
+  def server_unavailable explanation = "Server unavailable"
+    respond 41, explanation
+  end
+
+  def cgi_error explanation = "CGI error"
+    respond 42, explanation
+  end
+
+  def proxy_error explanation = "Proxy error"
+    respond 43, explanation
+  end
+
+  def slow_down delay
+    respond 44, delay
+  end
+
+  def permanent_failure explanation = "Permanent failure"
+    respond 50, explanation
+  end
+
+  def not_found explanation = "Not found"
+    respond 51, explanation
+  end
+
+  def gone explanation = "Gone"
+    respond 52, explanation
+  end
+
+  def proxy_request_refused explanation = "Proxy request refused"
+    respond 53, explanation
+  end
+
+  def bad_request explanation = "Bad request"
+    respond 59, explanation
+  end
+
+  def client_certificate_required explanation = "Client certificate required"
+    respond 60, explanation
+  end
+  alias certificate_required client_certificate_required
+
+  def certificate_not_authorized explanation = "Certificate not authorized"
+    respond 61, explanation
+  end
+
+  def certificate_not_valid explanation = "Certificate not valid"
+    respond 62, explanation
+  end
+end

data/lib/gemini_server/version.rb

@@ -0,0 +1,3 @@
+module GeminiServer
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: gemini_server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jess Bees
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: async-io
+  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: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: localhost
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: ''
+email:
+- hi@toomanybees.com
+executables:
+- gemini_server
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/gemini_server
+- gemini_server.gemspec
+- lib/gemini_server.rb
+- lib/gemini_server/mime_types.rb
+- lib/gemini_server/responses.rb
+- lib/gemini_server/version.rb
+homepage: http://github.com/TooManyBees/gemini_server
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/TooManyBees/gemini_server
+  source_code_uri: http://github.com/TooManyBees/gemini_server
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Simple server for the Gemini protocol
+test_files: []