blest 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4f44d941bb783457e67fa52ada69792f5f645a76bac399165d59c73f4ba7b4b
-  data.tar.gz: 8f7ee45d396ae4cab3c8178f1bef7e6605612efb94e259cbb35bcd3da842e347
+  metadata.gz: eb15eb80f38f62587b534d5ce5e5a81a0a8995050033745b2f100fede9557794
+  data.tar.gz: b7e758f3d3396af0f14952b3512c5e2550f7a35089add6aaf479994bb4ed778a
 SHA512:
-  metadata.gz: aecfa3005a9a29bcfd4b4f501710a0f8a49251ff7fc62f4043bfe8e5b0e7f6c8e2ddbb09df2ae14c08bc7617a09ab08d84ed52d9023272bd9bb05dabd1fb8e41
-  data.tar.gz: 2855b895975b23f418e0e084ecd3d15bd8df43764a896aca1f8fa5788d21e74ab7fb5ff5fdc4bbcd79a074dff7ce2f14bb3a10ee4e497d8ef1d63b1a645066c3
+  metadata.gz: 3c18640e749fb37f65d380ac18966002662b652081bafb908e9e7a1771dbae30348272888ae60bdf4f254fefeec6f4c2c822b2fc47341a4469312413c03f45d9
+  data.tar.gz: 731fedd0800a8e82a9ab3d7bd07e1bd6b29b88145ce8d43054f7d52b2519a6e46f8472273c8bfa85b5aaf7451d6821b19c698a3f97319b823b7c78947a47bbfd

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 JHunt
+Copyright (c) 2023-2024 JHunt
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -24,39 +24,9 @@ gem install blest
 
 ## Usage
 
-The `Blest` class of this library has an interface similar to Sinatra. It also provides a `Router` class with a `handle` method for use in an existing Ruby API and an `HttpClient` class with a `request` method for making BLEST HTTP requests.
-
-```ruby
-require 'blest'
-
-app = Blest.new(timeout: 1000, port: 8080, host: 'localhost', cors: 'http://localhost:3000')
-
-# Create some middleware (optional)
-app.before do |body, context|
-  if context.dig('headers', 'auth') == 'myToken'?
-    context['user'] = {
-      # user info for example
-    }
-    nil
-  else
-    raise RuntimeError, "Unauthorized"
-  end
-end
-
-# Create a route controller
-app.route('greet') do |body, context|
-  {
-    greeting: "Hi, #{body['name']}!"
-  }
-end
-
-# Start the server
-app.listen
-```
-
 ### Router
 
-The following example uses Sinatra.
+The following example uses Sinatra, but you can find examples with other frameworks [here](examples).
 
 ```ruby
 require 'sinatra'
@@ -68,14 +38,9 @@ router = Router.new(timeout: 1000)
 
 # Create some middleware (optional)
 router.before do |body, context|
-  if context.dig('headers', 'auth') == 'myToken'?
-    context['user'] = {
-      # user info for example
-    }
-    nil
-  else
-    raise RuntimeError, "Unauthorized"
-  end
+  context['user'] = {
+    # user info for example
+  }
 end
 
 # Create a route controller
@@ -111,7 +76,7 @@ client = HttpClient.new('http://localhost:8080', max_batch_size = 25, buffer_del
 
 # Send a request
 begin
-  result = client.request('greet', { 'name': 'Steve' }, ['greeting']).value
+  result = client.request('greet', { 'name': 'Steve' }).value
   # Do something with the result
 rescue => error
   # Do something in case of error

data/lib/blest.rb

@@ -1,4 +1,3 @@
-require 'socket'
 require 'json'
 require 'concurrent'
 require 'securerandom'
@@ -148,29 +147,6 @@ end
 
 
 
-class Blest < Router
-  @options = nil
-  @errorhandler = nil
-
-  def initialize(options = nil)
-    @options = options
-    super(options)
-  end
-
-  def errorhandler(&errorhandler)
-    @errorhandler = errorhandler
-    puts 'The errorhandler method is not currently used'
-  end
-
-  def listen(*args)
-    request_handler = create_request_handler(@routes)
-    server = create_http_server(request_handler, @options)
-    server.call(*args)
-  end
-end
-
-
-
 class HttpClient
   attr_reader :queue, :futures
   attr_accessor :url, :max_batch_size, :buffer_delay, :headers
@@ -279,324 +255,6 @@ end
 
 
 
-class HttpServer
-  attr_reader :url, :host, :port, :cors, :headers
-
-  def initialize(request_handler, options = {})
-    unless request_handler.is_a?(Router)
-      raise ArgumentError, "request_handler must be an instance of Router class"
-    end
-    @request_handler = request_handler
-    if options
-      options_error = validate_server_options(options)
-      raise ArgumentError, options_error if options_error
-    else
-      @options = {}
-    end
-
-    @url = options && get_value(options, :url) || '/'
-    @host = options && get_value(options, :host) || 'localhost'
-    @port = options && get_value(options, :port) || 8080
-    @cors = options && get_value(options, :cors) || false
-    cors_default = cors == true ? '*' : cors || ''
-
-    @headers = {
-      'access-control-allow-origin' => options && get_value(options, :accessControlAllowOrigin) || cors_default,
-      'content-security-policy' => options && get_value(options, :contentSecurityPolicy) || "default-src 'self';base-uri 'self';font-src 'self' https: data:;form-action 'self';frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests",
-      'cross-origin-opener-policy' => options && get_value(options, :crossOriginOpenerPolicy) || 'same-origin',
-      'cross-origin-resource-policy' => options && get_value(options, :crossOriginResourcePolicy) || 'same-origin',
-      'origin-agent-cluster' => options && get_value(options, :originAgentCluster) || '?1',
-      'referrer-policy' => options && get_value(options, :referrerPolicy) || 'no-referrer',
-      'strict-transport-security' => options && get_value(options, :strictTransportSecurity) || 'max-age=1555200 includeSubDomains',
-      'x-content-type-options' => options && get_value(options, :xContentTypeOptions) || 'nosniff',
-      'x-dns-prefetch-control' => options && get_value(options, :xDnsPrefetchOptions) || 'off',
-      'x-download-options' => options && get_value(options, :xDownloadOptions) || 'noopen',
-      'x-frame-options' => options && get_value(options, :xFrameOptions) || 'SAMEORIGIN',
-      'x-permitted-cross-domain-policies' => options && get_value(options, :xPermittedCrossDomainPolicies) || 'none',
-      'x-xss-protection' => options && get_value(options, :xXssProtection) || '0'
-    }
-  end
-
-  def listen()
-    server = TCPServer.new(@host, @port)
-    puts "Server listening on port #{@port}"
-
-    loop do
-      client = server.accept
-      Thread.new { handle_http_request(client, @request_handler, @http_headers) }
-    end
-  end
-
-  private
-
-  def parse_http_request(request_line)
-    method, path, _ = request_line.split(' ')
-    { method: method, path: path }
-  end
-
-  def parse_http_headers(client)
-    headers = {}
-
-    while (line = client.gets.chomp)
-      break if line.empty?
-
-      key, value = line.split(':', 2)
-      headers[key] = value.strip
-    end
-
-    headers
-  end
-
-  def parse_post_body(client, content_length)
-    body = ''
-  
-    while content_length > 0
-      chunk = client.readpartial([content_length, 4096].min)
-      body += chunk
-      content_length -= chunk.length
-    end
-  
-    body
-  end
-
-  def build_http_response(status, headers, body)
-    response = "HTTP/1.1 #{status}\r\n"
-    headers.each { |key, value| response += "#{key}: #{value}\r\n" }
-    response += "\r\n"
-    response += body
-    response
-  end
-
-  def handle_http_request(client, request_handler, http_headers)
-    request_line = client.gets
-    return unless request_line
-  
-    request = parse_http_request(request_line)
-    
-    headers = parse_http_headers(client)
-  
-    if request[:path] != '/'
-      response = build_http_response('404 Not Found', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'OPTIONS'
-      response = build_http_response('204 No Content', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'POST'
-
-      content_length = headers['Content-Length'].to_i
-      body = parse_post_body(client, content_length)
-      
-      begin
-        json_data = JSON.parse(body)
-        context = {
-          'headers' => headers
-        }
-
-        response_headers = http_headers.merge({
-          'Content-Type' => 'application/json'
-        })
-
-        result, error = request_handler.(json_data, context)
-
-        if error
-            response_json = error.to_json
-            response = build_http_response('500 Internal Server Error', response_headers, response_json)
-            client.print response
-        elsif result
-            response_json = result.to_json
-            response = build_http_response('200 OK', response_headers, response_json)
-            client.print response
-        else
-          response = build_http_response('500 Internal Server Error', response_headers, { 'message' => 'Request handler failed to return a result' }.to_json)
-          client.print response
-        end
-
-      rescue JSON::ParserError
-        response = build_http_response('400 Bad Request', http_headers, '')
-      end
-
-    else
-      response = build_http_response('405 Method Not Allowed', http_headers, '')
-      client.print(response)
-    end
-    client.close()
-  end
-
-end
-
-
-
-
-
-
-
-def create_http_server(request_handler, options = nil)
-  if options
-    options_error = validate_server_options(options)
-    raise ArgumentError, options_error if options_error
-  end
-
-  url = options && get_value(options, :url) || '/'
-  port = options && get_value(options, :port) || 8080
-  cors = options && get_value(options, :cors) || false
-  cors_default = cors == true ? '*' : cors || ''
-  
-  http_headers = {
-    'access-control-allow-origin' => options && get_value(options, :accessControlAllowOrigin) || cors_default,
-    'content-security-policy' => options && get_value(options, :contentSecurityPolicy) || "default-src 'self';base-uri 'self';font-src 'self' https: data:;form-action 'self';frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests",
-    'cross-origin-opener-policy' => options && get_value(options, :crossOriginOpenerPolicy) || 'same-origin',
-    'cross-origin-resource-policy' => options && get_value(options, :crossOriginResourcePolicy) || 'same-origin',
-    'origin-agent-cluster' => options && get_value(options, :originAgentCluster) || '?1',
-    'referrer-policy' => options && get_value(options, :referrerPolicy) || 'no-referrer',
-    'strict-transport-security' => options && get_value(options, :strictTransportSecurity) || 'max-age=1555200 includeSubDomains',
-    'x-content-type-options' => options && get_value(options, :xContentTypeOptions) || 'nosniff',
-    'x-dns-prefetch-control' => options && get_value(options, :xDnsPrefetchOptions) || 'off',
-    'x-download-options' => options && get_value(options, :xDownloadOptions) || 'noopen',
-    'x-frame-options' => options && get_value(options, :xFrameOptions) || 'SAMEORIGIN',
-    'x-permitted-cross-domain-policies' => options && get_value(options, :xPermittedCrossDomainPolicies) || 'none',
-    'x-xss-protection' => options && get_value(options, :xXssProtection) || '0'
-  }
-
-  def parse_http_request(request_line)
-    method, path, _ = request_line.split(' ')
-    { method: method, path: path }
-  end
-
-  def parse_http_headers(client)
-    headers = {}
-
-    while (line = client.gets.chomp)
-      break if line.empty?
-
-      key, value = line.split(':', 2)
-      headers[key] = value.strip
-    end
-
-    headers
-  end
-
-  def parse_post_body(client, content_length)
-    body = ''
-  
-    while content_length > 0
-      chunk = client.readpartial([content_length, 4096].min)
-      body += chunk
-      content_length -= chunk.length
-    end
-  
-    body
-  end
-
-  def build_http_response(status, headers, body)
-    response = "HTTP/1.1 #{status}\r\n"
-    headers.each { |key, value| response += "#{key}: #{value}\r\n" }
-    response += "\r\n"
-    response += body
-    response
-  end
-
-  def handle_http_request(client, request_handler, http_headers)
-    request_line = client.gets
-    return unless request_line
-  
-    request = parse_http_request(request_line)
-    
-    headers = parse_http_headers(client)
-  
-    if request[:path] != '/'
-      response = build_http_response('404 Not Found', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'OPTIONS'
-      response = build_http_response('204 No Content', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'POST'
-
-      content_length = headers['Content-Length'].to_i
-      body = parse_post_body(client, content_length)
-      
-      begin
-        json_data = JSON.parse(body)
-        context = {
-          'headers' => headers
-        }
-
-        response_headers = http_headers.merge({
-          'Content-Type' => 'application/json'
-        })
-
-        result, error = request_handler.(json_data, context)
-
-        if error
-            response_json = error.to_json
-            response = build_http_response('500 Internal Server Error', response_headers, response_json)
-            client.print response
-        elsif result
-            response_json = result.to_json
-            response = build_http_response('200 OK', response_headers, response_json)
-            client.print response
-        else
-          response = build_http_response('500 Internal Server Error', response_headers, { 'message' => 'Request handler failed to return a result' }.to_json)
-          client.print response
-        end
-
-      rescue JSON::ParserError
-        response = build_http_response('400 Bad Request', http_headers, '')
-      end
-
-    else
-      response = build_http_response('405 Method Not Allowed', http_headers, '')
-      client.print(response)
-    end
-    client.close()
-  end
-
-  run = ->() do
-
-    server = TCPServer.new('localhost', port)
-    puts "Server listening on port #{port}"
-
-    begin
-      loop do
-        client = server.accept
-        Thread.new { handle_http_request(client, request_handler, http_headers) }
-      end
-    rescue Interrupt
-      exit 1
-    end
-
-  end
-
-  return run
-end
-
-
-
-def validate_server_options(options)
-  if options.nil? || options.empty?
-    return nil
-  elsif !options.is_a?(Hash)
-    return 'Options should be a hash'
-  else
-    if options.key?(:url)
-      if !options[:url].is_a?(String)
-        return '"url" option should be a string'
-      elsif !options[:url].start_with?('/')
-        return '"url" option should begin with a forward slash'
-      end
-    end
-
-    if options.key?(:cors)
-      if !options[:cors].is_a?(String) && !options[:cors].is_a?(TrueClass) && !options[:cors].is_a?(FalseClass)
-        return '"cors" option should be a string or boolean'
-      end
-    end
-  end
-
-  return nil
-end
-
-
-
 def create_request_handler(routes)
   raise ArgumentError, 'A routes object is required' unless routes.is_a?(Hash)
 
@@ -884,8 +542,9 @@ def route_reducer(handler, request, context, timeout = nil)
     end
 
     # if request[:selector]
-    #   result = filter_object(result, request[:selector])
-    # end
+    if request&.headers&._s
+      result = filter_object(result, request.headers._s)
+    end
 
     [request[:id], request[:route], result, nil]
   rescue => error

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blest
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - JHunt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-28 00:00:00.000000000 Z
+date: 2024-12-29 00:00:00.000000000 Z
 dependencies: []
 description: The Ruby reference implementation of BLEST (Batch-able, Lightweight,
   Encrypted State Transfer), an improved communication protocol for web APIs which
@@ -36,7 +36,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="