tsurezure 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a04f09bb09e26d531a84b5738dd7719b2dee55ef2c73845bca3700c1a5f20c25
+  data.tar.gz: 6b3c83431259f111dd024f00860dfa9e10a8caad5e123f51b7085ca6dbced9db
+SHA512:
+  metadata.gz: '038ed41337233b9e7debfaed3da1d2984f8d2e11b46e02ed175da71e12eab878433a4151cefa06fbf0b247dd19d4eff5acb2fb252b6951f0df0084397eae4c14'
+  data.tar.gz: b9a87b64323fb67155ff68f24f3c390807663de010b39c57d2a73a5aa4559181994603bc41b11ba44af74bc3824b78e317368166a63a37e4c2091b2159b342fa

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 e. brown
+
+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/lib/tsurezure.rb

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'pry'
+
+require_relative 'utils/http_utils' # mainly used to create http responses.
+require_relative 'utils/object_utils' # various object  validation utilities
+require_relative 'utils/error_codes' # for generating errors.
+require_relative 'utils/response' # handles request and generates responses.
+
+$TRZR_PROCESS_MODE = nil
+$TRZR_LOG = true
+
+ARGV.each do |arg|
+  $TRZR_PROCESS_MODE = 'development' if arg == '--development'
+  $TRZR_PROCESS_MODE = 'production' if arg == '--production'
+  $TRZR_LOG = false if arg == '--silent'
+end
+
+$TRZR_PROCESS_MODE = 'production' if $TRZR_PROCESS_MODE.nil?
+
+# main class for tsurezure.
+class Tsurezure
+  include OUtil
+
+  ##
+  # this class is made to handle requests coming from
+  # a single client on a tcp server.
+  class RequestHandler
+    include HTTPUtils
+    include ErrorCodes
+    include TResponse
+
+    ##
+    # initializes with a client socket returned from a +TCPSocket+ object.
+
+    def initialize(session)
+      @session = session
+      # endpoints are organized into arrays, sorted by method.
+      # ex: { get: [ ...endpoint objects ], post: [ ... ] }
+      # etc.
+    end
+
+    ##
+    # handles an incoming request from the open socket in +@session+.
+    # constructs a formatted request object from the original request object,
+    # and calls +send_final_response+ in order to send a response.
+    def handle_request(request)
+      url_main = request[:url].split('?')[0]
+
+      request_object = {
+        method: request[:method],
+        url: url_main,
+        params: HTTPUtils::URLUtils.extract_url_params(request[:url]),
+        protocol: request[:protocol],
+        headers: request[:headers],
+        data: request[:data]
+      }
+
+      generate_response request_object
+    end
+
+    ##
+    # generate a response from a supplied request object
+    # from +handle_request+.
+    def generate_response(request_object)
+      type = 'text/plain'
+
+      unless request_object[:options].nil? || request_object[:options].empty?
+        type = request_object[:options][:content_type]
+      end
+
+      res = TResponse.get_response request_object, @endpoints
+
+      # to initialize: session and length of response
+      responder = HTTPUtils::ServerResponse.new(
+        @session,
+        res[:message].bytesize
+      )
+
+      go_through_middleware request_object, responder, res, type
+    end
+
+    def get_correct_middleware(request_object)
+      @middleware.keys.select do |pat|
+        HTTPUtils::URLUtils.matches_url_regex(pat, request_object[:url]) ||
+          pat == '*'
+      end
+    end
+
+    def fix_req(request, mid)
+      request[:vars] =
+        HTTPUtils::URLUtils.get_match_indices(
+          mid[:path_regex],
+          request[:url]
+        ) || {}
+
+      request[:options] = mid[:options]
+
+      request
+    end
+
+    def send_middleware_response(req, resp, type)
+      res = resp.merge req
+
+      responder = HTTPUtils::ServerResponse.new(
+        @session,
+        res[:message].bytesize
+      )
+
+      # pp res
+
+      responder.respond res[:message], res[:options] || {}, res[:status], type
+    end
+
+    def call_each_middleware(request, middleware, type)
+      alt = nil
+
+      middleware.each do |path|
+        break if alt
+
+        @middleware[path]&.each do |mid|
+          alt = mid[:callback].call fix_req(request, mid)
+        end
+      end
+
+      return true unless alt
+
+      send_middleware_response(request, alt, type)
+    end
+
+    def go_through_middleware(request_object, responder, res, type)
+      exp = get_correct_middleware request_object
+
+      done = call_each_middleware request_object, exp, type
+
+      return unless done
+
+      # to send: response, options, status, content_type
+      responder.respond res[:message], res[:options] || {}, res[:status], type
+    end
+
+    ##
+    # main process, allows server to handle requests
+    def process(client, endpoints, middleware)
+      @endpoints = endpoints
+      @middleware = middleware
+      @request = client.gets
+      # wait until server isn't recieving anything
+      return if @session.gets.nil?
+      return if @session.gets.chop.length.zero?
+
+      request_made = HTTPUtils.make_proper_request client, @request
+
+      request_to_handle = HTTPUtils.make_request_object request_made
+
+      handle_request request_to_handle
+    end
+  end
+
+  ##
+  # prepares the server to run on a specified port.
+  def initialize(port)
+    raise ErrorCodes.nan_error 'port' unless port.is_a? Numeric
+    raise ErrorCodes.range_error 0, 65_535 unless (0..65_535).include? port
+
+    @server = TCPServer.new port
+    @port = port
+    @endpoints = {}
+    @middleware = {}
+  end
+
+  attr_reader :endpoints # access endpoints object from outside scope
+
+  def add_middleware(path, callback, options)
+    unless path.is_a? String
+      raise ArgumentError, 'first argument to middleware\
+      must be string or function.'
+    end
+
+    middleware_object = {
+      options: options, callback: callback, path_regex: path
+    }
+
+    @middleware[path] << middleware_object if @middleware[path]
+
+    @middleware[path] = [middleware_object] unless @middleware[path]
+  end
+
+  def register(http_method, path, callback, options = nil)
+    http_method = http_method.upcase
+    insurance = ensure_registration http_method, path, callback, options
+
+    raise ArgumentError, insurance if insurance.class == String
+
+    # register a new endpoint but do not register dupes
+    @endpoints[http_method] = {} unless @endpoints.key? http_method
+
+    new_endpoint = { path: path, responder: callback, options: options }
+
+    add_new_endpoint new_endpoint, http_method
+  end
+
+  ##
+  # run when the server is prepared to accept requests.
+  def listen
+    puts "running on port #{@port}!"
+    # create a new thread for handle each incoming request
+    loop do
+      Thread.start(@server.accept) do |client|
+        RequestHandler.new(client).process client, @endpoints, @middleware
+      end
+    end
+  end
+
+  private
+
+  # ----------------------------------------
+  # :section: registration of endpoints and
+  # all endpoint management methods follow.
+  # ----------------------------------------
+
+  def ensure_registration(*args)
+    verification = verify_registration(*args)
+
+    return verification unless verification
+
+    verification # to register
+  end
+
+  def validate_registration_params(method, path, responder)
+    unless TResponse::Utils.new.valid_methods.include? method
+      return "#{method} is not a valid http method."
+    end
+
+    return 'invalid path type. must be a string.' unless path.class == String
+
+    if path.empty? || path.chr != '/'
+      return 'invalid path. must begin with "/".'
+    end
+
+    return 'invalid responder type. must a proc.' unless responder.class == Proc
+
+    true
+  end
+
+  def verify_registration(http_method, path, responder, options)
+    valid = validate_registration_params http_method, path, responder
+
+    return valid unless valid == true
+    return true if options.nil? || options.empty?
+    return 'invalid options type.' unless options.class == Hash
+
+    valid_opts = %w[content_type method location]
+
+    opts_valid = OUtil.check_against_array(options.keys, valid_opts, 'register')
+
+    return 'invalid options provided to register.' unless opts_valid
+
+    true # to ensure_registration
+  end
+
+  def add_new_endpoint(endpoint, method)
+    @endpoints[method].each do |_, value|
+      if value[:path] == endpoint[:path]
+        raise ArgumentError, 'cannot register duplicate path.'
+      end
+    end
+
+    # add endpoint to list of registered endpoints
+    @endpoints[method][endpoint[:path]] = endpoint
+  end
+
+  def kill
+    abort
+  end
+end
+
+at_exit { puts 'shutting down. goodbye...' }

data/lib/utils/error_codes.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# for storing generic, reusable error codes.
+module ErrorCodes
+  def self.nan_error(item)
+    "invalid parameter: #{item} must be a number."
+  end
+
+  def self.no_method_error(item)
+    "invalid http method: #{item} is not a valid http method."
+  end
+
+  def self.invalid_type_error(item)
+    "invalid type: #{item} is not a valid type."
+  end
+
+  def self.range_error(min, max)
+    "invalid port number: port must be in range [#{min}, #{max}]"
+  end
+
+  def self.invalid_structure_error(keys, method)
+    "invalid object with keys #{keys} supplied to #{method}"
+  end
+end

data/lib/utils/errors.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# simple methods for showing error messages
+module ErrorMessage
+  def self.invalid_key_error(method, key)
+    raise ArgumentError, {
+      message: "invalid key '#{key}' used as parameter to #{method}."
+    }.to_json
+  end
+
+  def self.invalid_http_method_error(key, val, method)
+    raise ArgumentError, {
+      message: "#{key} used to access #{method}. use #{val}.",
+      status: 405,
+      options: {
+        allowed: val
+      }
+    }.to_json
+  end
+
+  def self.missing_arguments_error(method)
+    raise ArgumentError, {
+      status: 500,
+      message: "missing arguments to #{method}"
+    }.to_json
+  end
+
+  def self.missing_parameter_error(method)
+    raise ArgumentError, {
+      status: 400,
+      message: "missing url parameter id to #{method}."
+    }.to_json
+  end
+
+  def self.invalid_structure_error(method, keys)
+    raise ArgumentError, {
+      status: 400,
+      message: "invalid object with keys #{keys} passed to #{method}."
+    }.to_json
+  end
+
+  def self.make_http_error(status, message, options)
+    error = { status: status, options: options }
+    error.delete :options if options.nil?
+
+    case status.to_s.chr.to_i
+    when 4
+      error[:message] = "bad request: #{message}"
+    when 5
+      error[:message] = "server error: #{message}"
+    end
+
+    error.to_json
+  end
+end
+
+# module for multiple custom error classes
+module CustomError
+  # for throwing a server error (like 500)
+  class ServerError < StandardError
+    def initialize(message = 'an internal server error occurred.')
+      super
+    end
+  end
+end

data/lib/utils/http_utils.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative 'logbook'
+
+# all utilities for dealing with http-related things
+module HTTPUtils
+  include Logbook
+  # class URLUtils - for dealing with urls
+  class URLUtils
+    def self.extract_url_params(url)
+      url_params = {}
+
+      if url.split('?')
+            .length > 1
+        url.split('?')[1].split('&').map do |e|
+          key, value = e.split('=')
+
+          break if value.nil?
+
+          url_params[key] = value
+        end
+      end
+
+      url_params
+    end
+
+    def self.url_path_matches?(url, path)
+      split_url = url.split '/'
+      split_path = path.split '/'
+
+      return false if split_url.empty? || split_url.length != split_path.length
+
+      true
+    end
+
+    def self.get_match_indices(url, path)
+      split_url = url.split '/'
+      split_path = path.split '/'
+
+      hash_with_variables = {}
+
+      return unless url_path_matches? url, path
+
+      split_url.each_with_index do |pname, idx|
+        part = pname.sub(':', '')
+        hash_with_variables[part] = split_path[idx] if pname[0] == ':'
+      end
+
+      hash_with_variables
+    end
+
+    def self.matches_url_regex(url, regex)
+      return unless url_path_matches? url, regex
+
+      matches = url.scan %r{((?<=\/):[^\/]+)}
+      newregexp = url.dup
+
+      return url.match? Regexp.new("^#{regex}$") if matches.empty?
+
+      matches.each do |mat|
+        newregexp.gsub!(Regexp.new(mat[0].to_s), '.+')
+      end
+
+      url.match? Regexp.new(newregexp)
+    end
+  end
+
+  # for dealing with header data.
+  class HeaderUtils
+    def self.get_headers(client)
+      headers = {}
+
+      while (line = client.gets.split(' ', 2))
+        break if line[0] == ''
+
+        headers[line[0].chop] = line[1].strip
+      end
+
+      headers
+    end
+
+    def self.get_req_data(client, headers)
+      data = client.read headers['Content-Length'].to_i
+
+      return if data.empty?
+
+      data
+    end
+  end
+
+  def self.make_proper_request(client, request)
+    headers = HeaderUtils.get_headers(client)
+    data = HeaderUtils.get_req_data(client, headers)
+    method = request.split(' ')[0]
+    url = request.split(' ')[1]
+    proto = request.split(' ')[2]
+
+    { headers: headers, data: data, method: method, url: url, protocol: proto }
+  end
+
+  def self.make_request_object(req)
+    req[:data] = '{}' if req[:data].nil?
+
+    {
+      headers: req[:headers],
+      data: JSON.parse(req[:data]),
+      method: req[:method],
+      url: req[:url],
+      protocol: req[:protocol]
+    }
+  end
+
+  # class ServerResponses - for sending HTTP responses
+  class ServerResponse
+    def initialize(session, length)
+      @session = session
+      @length = length
+    end
+
+    def valid_options?(options)
+      acceptable_keys = %i[location method]
+
+      return true if acceptable_keys.any? { |key| options.key? key }
+
+      false
+    end
+
+    def respond(response,
+                options = {},
+                status = 200,
+                content_type = 'application/json')
+      @content_type = options[:content_type] || content_type
+
+      if respond_to? "r_#{status}"
+        method("r_#{status}").call unless valid_options? options
+        method("r_#{status}").call options if valid_options? options
+      else
+        r_400
+      end
+
+      @session.puts
+      @session.puts response
+      @session.close
+    end
+
+    def r_200
+      @session.puts 'HTTP/1.1 200 OK'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+
+    def r_201
+      @session.puts 'HTTP/1.1 201 Created'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+
+    def r_301(options)
+      @session.puts 'HTTP/1.1 301 Moved Permanently'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+      @session.puts "Location: #{options[:location]}"
+    end
+
+    def r_304
+      @session.puts 'HTTP/1.1 304 Not Modified'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+
+    def r_400
+      @session.puts 'HTTP/1.1 400 Bad Request'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+
+    def r_404
+      @session.puts 'HTTP/1.1 404 Not Found'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+
+    def r_405(options)
+      @session.puts 'HTTP/1.1 405 Method Not Allowed'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+      @session.puts "Allow: #{options[:method]}"
+    end
+
+    def r_500
+      @session.puts 'HTTP/1.1 500 Internal Server Error'
+      @session.puts "Content-Type: #{@content_type}"
+      @session.puts "Content-Length: #{@length}"
+    end
+  end
+end
+
+__END__
+
+this is the file that made me realize that the content_length header actually directly controls the length of the content in the response. I incorrectly set the content_length once as a mistake, and my responses were coming out short. interesting!

data/lib/utils/logbook.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# module for logging things
+module Logbook
+  # dev mode logging
+  class Dev
+    def self.log_json(data, break_around = true, tag = 'info')
+      return unless $TRZR_PROCESS_MODE == 'development' && $TRZR_LOG == true
+
+      if break_around
+        puts "\r\n#{tag} - #{caller.first}".black.bg_green
+        puts JSON.pretty_generate data
+        puts
+      else
+        puts "#{tag}\r\n#{caller.first}"
+        pp data
+      end
+    end
+
+    def self.log(data, break_around = true, tag = 'info')
+      return unless $TRZR_PROCESS_MODE == 'development' && $TRZR_LOG == true
+
+      if break_around
+        puts "\r\n#{tag} - #{caller.first}".black.bg_green
+        pp data
+        puts
+      else
+        puts "#{tag}\r\n#{caller.first}"
+        pp data
+      end
+    end
+  end
+end
+
+# some slight mods to the string class to allow colorization
+class String
+  def green
+    "\e[32m#{self}\e[0m"
+  end
+
+  def blue
+    "\e[34m#{self}\e[0m"
+  end
+
+  def black
+    "\e[30m#{self}\e[0m"
+  end
+
+  def bg_red
+    "\e[41m#{self}\e[0m"
+  end
+
+  def bg_green
+    "\e[42m#{self}\e[0m"
+  end
+end

data/lib/utils/object_utils.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+# module for validating object structure, keys etc.
+module OUtil
+  include ErrorMessage
+  # check url params to make sure they're not empty
+  # on methods that require them
+  def self.check_params(params, method)
+    return unless params.nil? || params.empty?
+
+    raise ErrorMessage.missing_parameter_error(method)
+  end
+
+  # make sure a key is the correct value
+  def self.check_key(key, value, method)
+    return if key == value
+
+    raise ErrorMessage.invalid_key_error(method, key)
+  end
+
+  def self.check_http_method(key, value, method)
+    return if key == value
+
+    raise ErrorMessage.invalid_http_method_error(key, value, method)
+  end
+
+  def check_key_type(object, key, type, method)
+    return if object[key].is_a? type
+
+    raise ErrorMessage.invalid_key_error(method, key)
+  end
+
+  def self.check_object_keys(keys, valid_keys, method)
+    key_bank = []
+
+    keys.each do |key|
+      break unless valid_keys.keys.include? key.to_sym
+      break unless key.is_a? valid_keys[key.to_sym]
+
+      key_bank.push key
+    end
+
+    return if key_bank.length == valid_keys.length
+
+    raise ErrorMessage.invalid_structure_error(method, "(#{keys.join(', ')})")
+  end
+
+  def self.check_against_array(keys, valid_keys, method)
+    inv_keys = []
+
+    keys.each do |key|
+      key = key.to_s
+
+      inv_keys << key unless valid_keys.include? key
+    end
+
+    return true if inv_keys.length.zero?
+
+    raise ErrorMessage.invalid_structure_error(method, "(#{keys.join(', ')})")
+  end
+end

data/lib/utils/response.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative './http_utils' # mainly used to create http responses.
+
+##
+# module for handling all incoming requests to the server
+# stands for TsurezureResponse
+module TResponse
+  include HTTPUtils
+  # anything that will be needed to create responses
+  class Utils
+    def initialize
+      @valid_methods = %w[
+        CONNECT COPY DELETE GET HEAD
+        LINK LOCK MKCOL MOVE OPTIONS
+        OPTIONS PATCH POST PROPFIND
+        PROPPATCH PURGE PUT TRACE
+        UNLINK UNLOCK VIEW
+      ]
+    end
+
+    attr_reader :valid_methods
+
+    def self.validate_request(request_params)
+      # make sure the user has provided a valid http
+      # method, a valid uri, and a valid response /
+      # response type
+      valid_methods = %w[
+        CONNECT COPY DELETE GET HEAD
+        LINK LOCK MKCOL MOVE OPTIONS
+        OPTIONS PATCH POST PROPFIND
+        PROPPATCH PURGE PUT TRACE
+        UNLINK UNLOCK VIEW
+      ]
+
+      return false unless valid_methods.include? request_params[:method]
+    end
+
+    def self.get_correct_endpoint(request_object, endpoints)
+      endpoints.keys.select do |pat|
+        HTTPUtils::URLUtils.matches_url_regex(pat, request_object[:url])
+      end
+    end
+
+    def self.ensure_response(request, endpoints)
+      return false if request.nil? || request.empty?
+      return false if endpoints.nil? || endpoints.empty?
+
+      endpoint = endpoints[get_correct_endpoint(request, endpoints)[0]]
+
+      return false if endpoint.nil?
+
+      true
+    end
+  end
+
+  # creates the final response from the server
+  def self.get_response(request, endpoints)
+    Utils.validate_request request
+
+    @endpoints = endpoints[request[:method]]
+
+    # if no endpoint, respond with root endpoint or 404 middleware
+
+    unless Utils.ensure_response(request, @endpoints) == true
+      return { options: { content_type: 'application/json' },
+               code: 22, status: 404,
+               message: { status: 404, message: 'undefined endpoint' }.to_json }
+    end
+
+    endpoint = @endpoints[Utils.get_correct_endpoint(request, @endpoints)[0]]
+
+    # find the correct endpoint to respond with
+    activate_endpoint endpoint, request
+  end
+
+  def self.activate_endpoint(endpoint, request)
+    final = endpoint.merge request
+    final.delete :responder
+
+    final[:vars] =
+      HTTPUtils::URLUtils.get_match_indices(final[:path], final[:url])
+
+    response_from_endpoint = endpoint[:responder].call final
+
+    unless response_from_endpoint.is_a? Hash
+      return { status: 200, message: response_from_endpoint }
+    end
+
+    response_from_endpoint[:options] = final[:options]
+
+    response_from_endpoint
+  end
+end

data/nodemon.json

@@ -0,0 +1,5 @@
+{
+  "ignore": [".git"],
+  "watch": ["./"],
+  "ext": "rb, Gemfile"
+}

data/readme.md

@@ -0,0 +1,123 @@
+# tsurezure
+
+this is a simple web server framework written in ruby. mainly made as a way for me to quickly put together rest apis in my favorite language.
+
+it can be used in a very similar manner to the javascript framework express.
+
+* * *
+
+## usage
+
+### installing (from rubygems)
+
+just run `gem install tsurezure` and you'll have whatever the latest version is that I've put up.
+
+### installing (from source):
+
+requires:
+
+-   ruby
+-   nodejs + nodemon (**only** for hot reloading server in development mode, not necessarily required)
+
+after cloning this repo, from the root project directory, just run `rake start` to start in production mode, or `rake dev` to run in development mode, which adds hot reloading with nodemon. gem dependencies will install automatically.
+
+to build the gem: run `gem build tsurezure.gemspec`. then, install using `gem install tsurezure-version-number`. `version-number` is whatever version is installed based on the `.gemspec` file.
+
+### actually using tsurezure:
+
+as for how to use tsurezure, here's a simple hello world to get started:
+
+```ruby
+require 'tsurezure'
+
+# create an instance of tsurezure
+server = Tsurezure.new(8888)
+
+# url: http://localhost:8888/user/1
+
+# create an endpoint
+server.register 'get', '/user/:id', lambda { |req|
+  url_vars = req[:vars] # { "id" => "1" }
+  params = req[:params] # {}
+
+  # create a respsonse for the endpoint
+  {
+    status: 200,
+    message: {
+      message: "hello user ##{url_vars['id']}!"
+    }.to_json
+  }
+}, content_type: 'application/json' # options hash
+
+# throw in some middleware
+server.add_middleware '/user/:id', lambda { |req|
+  url_vars = req[:vars]
+
+  # show a different response based on the request itself.
+  # if you return from middleware, the return value will
+  # be sent as the final response.
+  if req[:vars]['id'] == '1'
+    return {
+      status: 200, message: {
+      message: "hey user #1! you're the first one here!"
+    }.to_json
+  }
+
+  end
+}, content_type: 'application/json'
+
+#listen for connections
+server.listen
+```
+
+after you run this file, open up your browser or whatever and go to `http://localhost:8888/user/1`. you should see a json response that looks like this:
+
+```json
+{
+    "message": "hey user #1! you're the first one here!"
+}
+```
+
+the registration function for creating endpoints is very simple:
+
+```ruby
+register http_method, path, callback, options
+```
+
+`http_method` is the method to access the endpoint with. `path` is just the url.
+
+`path` can be a path that contains variables (such as `/user/:id`). see the example above to see how it works.
+
+`callback` is a lambda that contains the logic used to send a response. it will recieve one argument: the request that was sent to that endpoint. whatever is returned from the proc will be sent as the response from that endpoint.
+
+`options` is a hash containing various options to somehow modify the response. valid options:
+
+-   `content_type` - determines the mime type of the response
+-   `location` - if a location header is required (301, etc), this is used to provide it.
+-   `method` - if an allow header is required (405), this is used to provide it.
+
+for middleware, it's much the same:
+
+```ruby
+add_middleware path, callback, options
+```
+
+`path` can be a path that contains variables. used in the same way as the `path` for endpoints.
+
+`callback` is a lambda that you can use to intercept and pre-process responses. if you return from a callback in middleware, then that return value will be sent as the final response.
+
+`options` for middleware are the same as the `options` for endpoints.
+
+* * *
+
+## todo
+
+-   [ ]  make it so registered uris can only be accessed with the specified method, and everything else returns a 405 (maybe make this an option??)
+
+-   [ ]  give the user an option to add middleware specifically for catching errors
+
+## misc
+
+disclaimer: I don't know ruby, and this is my first time using it to make something.
+
+the name comes from yukueshirezutsurezure, one of my favorite bands. it's pronounced 'tsɯ-ɾe-dzɯ-ɾe.'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: tsurezure
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- jpegzilla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: a simple ruby web server framework. like a ball of loose yarn...
+email: eris@jpegzilla.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/tsurezure.rb
+- lib/utils/error_codes.rb
+- lib/utils/errors.rb
+- lib/utils/http_utils.rb
+- lib/utils/logbook.rb
+- lib/utils/object_utils.rb
+- lib/utils/response.rb
+- nodemon.json
+- readme.md
+homepage: https://github.com/jpegzilla/tsurezure
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+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: 3.0.3
+signing_key: 
+specification_version: 4
+summary: tsurezure is a simple web server framework.
+test_files: []