raindeer 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ff951a5eafc6d661e188c1eb78fb01ae2a148544fd897da8731800305335f2f
-  data.tar.gz: d821af08d8333a88da073564db2f699e905de22fa825ed89ac41dca5dd48fd4b
+  metadata.gz: 8d79ce92ce79c7e46122adb4e9ba39968d9bf220cca424deba580f3a74ac26c6
+  data.tar.gz: 6970876678afd4bf8395135d52a9c1ff20858170282e3c97c540f1458338d4ea
 SHA512:
-  metadata.gz: 6c8cc7383ae033d78736e5c7db85057f4a2ab4bbd8b5634d4efc7164b96112dd25ac94e31216f9cbe2ab06a99fa70f1b34a9f742da6725ff3f0fe7295b99f0f2
-  data.tar.gz: 52bd7181b0e4bb0a9a4cf17a0802428849a1a0e5543f1443721661c58c229f528e6e49fc0f97866a5092d2e42772a2ca26cbdd67d61da7b5bca50857ade3bd0c
+  metadata.gz: 947dd01220faa492c9abf83e78aae9ec07d5e6c5794724aa24dda43be39e8fe82822734c068612f1176246c64b3e5f34e205d5b2fbb7d5517be598d3e927b1f2
+  data.tar.gz: bb4fff4358eae10a7b3ee1085ad9bd35bd7ac795c639dcb48b8e7c7deea3055e592a1f196931fc98ad64161631b5107bd1ca75fe29086d415891e7cfc23d84d3

data/lib/boot.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'low_loop'
-require 'low_dependency'
+require 'low_event'
+require 'low_node'
+require 'low_type'
+require 'providers'
 
 require_relative 'support/config_loader'
 
@@ -15,12 +17,20 @@ env = {
 
 config = Rain::ConfigLoader.load('./config/config.yaml', env)
 
-LowDependency.provide('rain.router') do
-  RainRouter.new
+Providers.define('rain.router') do
+  require_relative 'router/router'
+  Rain::Router.new
 end
 
-LowDependency.provide('low.loop') do
-  LowLoop.new(config:, router: Low::Providers['rain.router'])
+Providers.define('rain.matrix') do
+  require_relative 'matrix/matrix'
+  Rain::Matrix.new(event_pool: Providers['low.event.pool'])
 end
 
-require_relative 'system/system'
+Providers.define('low.loop') do
+  require 'low_loop'
+  LowLoop.new(config:, router: Providers['rain.router'], renderer: Providers['rain.matrix'])
+end
+
+require 'lowload'
+LowLoad.dirload(File.expand_path('system', __dir__))

data/lib/matrix/cursor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rain
+  class Cursor
+    attr_accessor :index, :first_update, :last_update
+
+    def initialize
+      @index = -1
+      @first_update = now
+      @last_update = now
+    end
+
+    # Unit tests use "duration" to skip forward in time, while feature tests and the real world use old fashioned linear time.
+    def increment(delays:, inputs:, duration: nil)
+      next_index = next_index(loop_count: inputs.count)
+
+      return unless delays[next_index] && (duration || now - @last_update) >= delays[next_index]
+
+      @index = next_index
+      @last_update = now
+
+      yield index
+    end
+
+    def iterate(inputs:, loop_count:)
+      inputs.each do |input|
+        @index += 1
+        @index = 0 if index >= loop_count
+
+        yield index, input
+      end
+    end
+
+    def increase_index(loop_count:)
+      @index += 1
+      @index = 0 if @index >= loop_count
+    end
+
+    def next_index(loop_count:)
+      next_index = @index + 1
+      next_index = 0 if next_index >= loop_count
+      next_index
+    end
+
+    private
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+  end
+end

data/lib/matrix/matrix.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'low_event'
+require 'observers'
+require 'paint'
+
+require_relative '../support/config_loader'
+require_relative 'stream'
+
+module Rain
+  class Matrix
+    include Observers
+
+    def initialize(event_pool:, config: ConfigLoader.load('./config/matrix.yaml'))
+      @event_pool = event_pool
+      @config = config
+
+      @screen_size = nil
+
+      @last_stream_index = -1
+      @streams = {} # TODO: Could be a "stream pool" like event pool (a pool hash).
+      @columns = []
+    end
+
+    def redraw(screen_size:)
+      @setup ||= setup
+
+      @streams.each_value do |stream|
+        stream.redraw(cell_count: screen_size[:row_count])
+      end
+    end
+
+    def render(screen_size:, show_output: true)
+      if screen_size != @screen_size
+        @screen_size = screen_size
+        redraw(screen_size:)
+      end
+
+      render_streams(show_output:)
+    end
+
+    # TODO: Introduce "on :new_event_tree do |event|" block construct in LowEvent for making event handlers more obvious.
+    # TODO: Observers should allow arbitrary params when triggering and observing.
+    def new_event_tree(event: Low::Events::EventTree)
+      stream = upsert_stream(event_tree: event)
+      stream.redraw(cell_count: @screen_size[:row_count])
+    end
+
+    private
+
+    def setup
+      @event_pool.event_trees.each_value do |event_tree|
+        upsert_stream(event_tree:)
+      end
+
+      observe @event_pool
+
+      true
+    end
+
+    def upsert_stream(event_tree:)
+      stream = @streams[event_tree.request_id] ||= Stream.new(index: generate_index, config: @config, event_tree:)
+      @columns[stream.index] = stream
+      stream
+    end
+
+    def render_streams(show_output: true) # rubocop:disable Metrics/AbcSize
+      @streams.each_value(&:render)
+
+      return unless show_output
+
+      output = ''.dup
+
+      (0...@screen_size[:row_count]).each do |row_index|
+        cell_outputs = []
+        cell_colors = []
+
+        # Rendering streams can happen before redrawing streams, so @columns may not be populated yet.
+        (0...column_count).each do |column_index|
+          cell_colors << (@columns[column_index].nil? ? nil : @columns[column_index].colors[row_index])
+          cell_outputs << (@columns[column_index].nil? ? nil : @columns[column_index].outputs[row_index])
+        end
+
+        output << "\n" + cell_outputs.zip(cell_colors).map do |cell, color| # rubocop:disable Style/StringConcatenation
+          cell ? Paint[cell, color] : Paint[' ']
+        end.join(' ')
+      end
+
+      system 'clear'
+      print output.delete_prefix("\n").delete_suffix("\n")
+    end
+
+    def generate_index
+      case @config.start_col
+      when :random
+        rand(0...column_count)
+      when :latest
+        @last_stream_index += 1
+        return @last_stream_index = 0 if @last_stream_index >= column_count
+
+        @last_stream_index
+      end
+    end
+
+    def column_count
+      return @screen_size[:column_count] if @screen_size[:column_count] < 10
+
+      (@screen_size[:column_count] / 2).to_i.clamp(1, nil)
+    end
+  end
+end

data/lib/matrix/stream.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'low_event'
+require 'observers'
+
+require_relative 'cursor'
+
+module Rain
+  class Stream
+    include Observers
+    attr_reader :index, :inputs, :outputs, :delays, :colors, :head_cursor, :tail_cursor
+
+    ARROW = ['│', '▼'].freeze
+
+    def initialize(index:, config:, event_tree:)
+      @index = index
+      @config = config
+      @event_tree = event_tree
+
+      @inputs = []
+      @delays = []
+      @colors = []
+      @outputs = []
+
+      @event_cursor = 0
+      @head_cursor = Cursor.new
+      @tail_cursor = Cursor.new
+      @tail_cursor.index = 0
+
+      @show_cursor = Cursor.new
+      @hide_cursor = Cursor.new
+
+      observe event_tree
+    end
+
+    # TODO: Use "on :branch do |event|" syntax.
+    def branch(event: Low::Events::BranchEvent) # rubocop:disable Lint/UnusedMethodArgument
+      redraw(cell_count: @inputs.count)
+    end
+
+    # Draw event names onto the current amount of cells in a stream, using cursors. Called when there's a new event.
+    #
+    #  INPUT DELAY OUTPUT
+    # ┌─────┬─────┬─────┐
+    # │  R  │  75 │     │ ◀── 2. Tail Cursor begins at index zero or a random starting index.
+    # │  e  │  75 │     │        A Head Cursor that wraps around will push the Tail Cursor down to be just beneath it.
+    # │  q  │  75 │     │        The Show Cursor will start at the Tail Cursor index.
+    # │  u  │  75 │     │
+    # │     │  75 │     │ ◀── 1. Head Cursor begins at index zero or a random starting index.
+    # │     │  75 │     │        It populates input for every character in an event name.
+    # │     │  75 │     │        Then sets a "75" delay for the Show Cursor.
+    # └─────┴─────┴─────┘
+    def redraw(cell_count:)
+      randomize_start_index if first_cell_redraw? && @config.start_row == :random
+      resize_cells(cell_count:) if cell_count != @inputs.count
+
+      (@event_cursor...@event_tree.sequence.count).each do |event_index|
+        current_event = @event_tree.sequence[event_index]
+        past_event = @event_tree.sequence[event_index - 1]
+
+        redraw_event(current_event:, past_event:)
+        @event_cursor += 1
+      end
+    end
+
+    # Render a cell's input as output after a delay, using cursors. Called on every frame.
+    #
+    #  INPUT DELAY OUTPUT
+    # ┌─────┬─────┬─────┐
+    # │     │   0 │     │ ◀── 2. Hide Cursor moves the input to the output after a delay.
+    # │     │ 250 │  e  │        The nil input replaces the previous output of "R".
+    # │     │ 250 │  q  │
+    # │     │ 250 │  u  │ ◀── 1. Show Cursor moves the input to the output after a delay.
+    # │  e  │  75 │     │        Leaving behind nil input.
+    # │  s  │  75 │     │        Then sets a "250" delay for the Hide Cursor.
+    # │  t  │  75 │     │
+    # └─────┴─────┴─────┘
+    #
+    # TODO: Refactor "@colors" into an Effect that happens dynamically on render rather than stored as a column of data.
+    #       This will reduce the "Metrics/AbcSize" complexity.
+    def render(duration: nil) # rubocop:disable Metrics/AbcSize
+      @show_cursor.increment(delays:, inputs:, duration:) do |index|
+        prev_index = index.zero? ? @inputs.count - 1 : index - 1
+        next_index = index + 1 >= @inputs.count ? 0 : index + 1
+
+        if @inputs[index]
+          @outputs[index] = @inputs[index]
+          @delays[index] = @config.fade_delay
+          @colors[prev_index] = @config.cell_color if @colors[prev_index]
+          @colors[index] = @outputs[next_index] ? @config.cell_color : @config.lead_color
+          @inputs[index] = nil
+        end
+      end
+
+      fade(duration:) if @config.fade
+    end
+
+    private
+
+    def fade(duration: nil)
+      fade_start_delay = rand(5_000..10_000)
+      return unless (now - @show_cursor.first_update) >= fade_start_delay || duration
+
+      @hide_cursor.increment(delays:, inputs:, duration:) do |index|
+        if @inputs[index].nil? && @outputs[index]
+          @outputs[index] = @inputs[index]
+          @delays[index] = 0
+        end
+      end
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
+    # A column of cells representing sequential events.
+    # ┌─┐
+    # │R│  FIRST EVENT
+    # │e│  Each cell will render input as output after a minimum delay (since there's no prior event).
+    # │q│
+    # │u│
+    # │e│
+    # │s│
+    # │t│
+    # └─┘ ◀── Time has passed between events.
+    # ┌─┐
+    # │││  SECOND EVENT
+    # │▼│  The next event has data to work with, it can represent the time it took to get from the previous event to the next.
+    # │R│  Each cell will delay render for the larger duration of either:
+    # │o│   1. The minimum delay
+    # │u│   2. The time elapsed between events divided by the number of cells
+    # │t│
+    # │e│ ◀── A cursor moves to the next cell after a delay and colors the leading cell white.
+    # └─┘
+    def redraw_event(current_event:, past_event:)
+      variable_delay = variable_delay(current_event:, past_event:)
+
+      characters = event_name(current_event:)
+      characters = [*ARROW, *characters] if @event_cursor > 0
+
+      @head_cursor.iterate(inputs: characters, loop_count: @inputs.count) do |index, input|
+        @inputs[index] = input
+        @delays[index] = first_cell_redraw? ? 0 : variable_delay # Don't add delay to the first cell, looks stuck.
+
+        @tail_cursor.increase_index(loop_count: @inputs.count) if @head_cursor.index == @tail_cursor.index
+      end
+
+      @hide_cursor.index = @head_cursor.index # Everything after me is old so it can fade away.
+    end
+
+    def variable_delay(current_event:, past_event:)
+      if @event_cursor.zero?
+        @config.min_delay
+      else
+        difference = current_event.created_at - past_event.created_at
+        difference.zero? ? @config.min_delay : (difference / inputs.count).to_i.clamp(@config.min_delay, nil)
+      end
+    end
+
+    def event_name(current_event:)
+      current_event.class.name.split('::').last.delete_suffix('Event').chars
+    end
+
+    def first_cell_redraw?
+      @head_cursor.index == -1
+    end
+
+    def resize_cells(cell_count:)
+      old_index = (@inputs.count - 1).clamp(0, nil)
+
+      @inputs = @inputs.fill(nil, old_index...cell_count)[0...cell_count]
+      @outputs = @outputs.fill(nil, old_index...cell_count)[0...cell_count]
+      @delays = @delays.fill(@config.min_delay, old_index...cell_count)[0...cell_count]
+      @colors = @colors.fill(@config.cell_color, old_index...cell_count)[0...cell_count]
+    end
+
+    def randomize_start_index
+      random_index = rand(0..2)
+
+      @head_cursor.index = random_index
+      @tail_cursor.index = random_index
+
+      @show_cursor.index = random_index
+    end
+  end
+end

data/lib/raindeer.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'low_dependency'
 require 'low_event'
 require 'low_node'
 require 'low_type'
 require 'observers'
+require 'providers'
 
 require_relative 'router/router'
 
-class Raindeer
+module Raindeer
   class << self
     def router(&block)
-      Low::Providers['rain.router'].instance_eval(&block)
+      Providers['rain.router'].instance_eval(&block)
     end
   end
 end

data/lib/router/route_event.rb

@@ -7,7 +7,7 @@ module Rain
     attr_reader :route, :params
 
     def initialize(route:, action: :render, params: Hash | nil)
-      super(action:)
+      super(key: route.path, action:)
 
       @route = route
       @params = params

data/lib/router/router.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'low_dependency'
 require 'low_event'
+require 'providers'
 
 require_relative 'route'
 require_relative 'route_event'
@@ -33,19 +33,19 @@ module Rain
       @breadcrumbs.pop
     end
 
-    def get(path = String, &block)
+    def get(path, &block)
       route(path, 'GET', &block)
     end
 
-    def post(path = String, &block)
+    def post(path, &block)
       route(path, 'POST', &block)
     end
 
-    def update(path = String, &block)
+    def update(path, &block)
       route(path, 'UPDATE', &block)
     end
 
-    def delete(path = String, &block)
+    def delete(path, &block)
       route(path, 'DELETE', &block)
     end
 
@@ -54,18 +54,14 @@ module Rain
     def handle(event:)
       response_event = nil
 
-      @trie.match(path: event.request.path).each do |route_event|
-        response_event = trigger route_event.route.path, event: route_event
+      # The last route event will render a response event which we want to return to the request event.
+      @trie.match(path: event.request.path.delete_suffix('/')).each do |route_event|
+        response_event = route_event.trigger
       end
 
-      if response_event.nil?
-        status = Low::Types::Status[404]
-        response_event = trigger status, action: :render, event: Low::Events::StatusEvent.new(status:, request: event.request)
-      end
+      return response_event if response_event
 
-      response_event
+      Low::Events::StatusEvent.trigger(status: Low::Types::Status[404], request: event.request)
     end
   end
 end
-
-RainRouter = Rain::Router

data/lib/router/trie.rb

@@ -66,7 +66,7 @@ module Rain
 
     private
 
-    # End nodes render events, mid nodes handle events.
+    # Mid nodes handle events, end nodes render events.
     def route_event(next_index:, params:, path:, route:)
       action = path[next_index].nil? ? :render : :handle
       RouteEvent.new(action:, route:, params:)

data/lib/support/config_loader.rb

@@ -6,11 +6,11 @@ require 'yaml'
 module Rain
   class ConfigLoader
     class << self
-      def load(filepath, env = {})
-        config_file = YAML.safe_load_file(filepath, symbolize_names: true)
+      def load(filepath, overrides = {})
+        config_file = YAML.safe_load_file(filepath, permitted_classes: [Symbol], symbolize_names: true)
 
         # Environment variables override config file.
-        config_data = config_file.merge(env) do |_key, old_value, new_value|
+        config_data = config_file.merge(overrides) do |_key, old_value, new_value|
           new_value.nil? ? old_value : new_value
         end
 

data/lib/system/dashboard_node.rbx

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class DashboardNode < LowNode
+  observe '/system'
+
+  def render(event:) # rubocop:disable Lint/UnusedMethodArgument
+    <{ LayoutNode: }>
+      <h1>{"Dashboard"}</h1>
+    <{ :LayoutNode }>
+  end
+end

data/lib/system/error_404_node.rbx

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Error404Node < LowNode
+  observe Low::Types::Status[404]
+
+  def render(event:) # rubocop:disable Lint/UnusedMethodArgument
+    <div class="page-not-found">
+      <em>404</em>
+    </div>
+  end
+end

data/lib/system/events_node.rbx

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class EventsNode < LowNode
+  observe '/system/events'
+
+  def initialize(event:)
+    @events = 'TODO: Populate via LowEvent inherited hook.'
+  end
+
+  def render(event:)
+    <{ LayoutNode: }>
+      <h1>{"Events"}</h1>
+
+      {@events}
+
+      <table>
+        <thead>
+          <tr>
+            <th scope="col">HTTP Verbs</th>
+            <th scope="col">Route</th>
+            <th scope="col">Observers</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>1</td>
+            <td>2</td>
+            <td>3</td>
+          </tr>
+        </tbody>
+      </table>
+    <{ :LayoutNode }>
+  end
+end

data/lib/system/layout_node.rbx

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class LayoutNode < LowNode
+  def render(event:)
+    <html>
+      <head>
+        <link rel="stylesheet" href="/assets/pico.min.css">
+        <link rel="stylesheet" href="/assets/system.css">
+      </head>
+      <body>
+        <header>
+          <div class="container">
+            <a id="favicon" href="/system"><img src="/assets/favicon.svg"/></a>
+            <nav id="navbar">
+              <ul>
+                <li><a href="/system">{"Dashboard"}</a>
+                <li><a href="/system/events">{"Events"}</a>
+                <li><a href="/system/routes">{"Routes"}</a>
+              </ul>
+            </nav>
+          </div>
+        </header>
+
+        <main class="container">
+          <{ :slot }>
+        </main>
+
+        <footer>
+          <div class="container">
+            <ul>
+              <li><a href="https://raindeer.dev">{"Website"}</a></li>
+              <li><a href="https://raindeer.dev/docs">{"Docs"}</a></li>
+              <li><a href="https://github.com/raindeer-rb/raindeer">{"Source code"}</a></li>
+            </ul>
+          </div>
+        </footer>
+      </body>
+    </html>
+  end
+end

data/lib/system/routes_node.rbx

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class RoutesNode < LowNode
+  observe '/system/routes'
+
+  def initialize(event:)
+    @routes = Providers['rain.router'].routes
+  end
+
+  def render(event:)
+    <{ LayoutNode: }>
+      <h1>{"Routes"}</h1>
+
+      {@routes}
+
+      <table>
+        <thead>
+          <tr>
+            <th scope="col">HTTP Verbs</th>
+            <th scope="col">Route</th>
+            <th scope="col">Observers</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>1</td>
+            <td>2</td>
+            <td>3</td>
+          </tr>
+        </tbody>
+      </table>
+    <{ :LayoutNode }>
+  end
+end

data/lib/system/system.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative '../raindeer'
-require_relative 'system_node'
 
 Raindeer.router do
-  get '/system'
+  get '/system' do
+    get '/events'
+    get '/routes'
+  end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindeer
-  VERSION = '0.1.2'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raindeer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: low_dependency
+  name: paint
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,6 +39,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: low_event
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: lowload
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -55,16 +69,16 @@ dependencies:
   name: low_loop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: low_node
   requirement: !ruby/object:Gem::Requirement
@@ -149,6 +163,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: providers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A new Ruby framework. Coming soon...
 email:
 - maediprichard@gmail.com
@@ -157,6 +185,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/boot.rb
+- lib/matrix/cursor.rb
+- lib/matrix/matrix.rb
+- lib/matrix/stream.rb
 - lib/raindeer.rb
 - lib/router/route.rb
 - lib/router/route_event.rb
@@ -164,9 +195,12 @@ files:
 - lib/router/trie.rb
 - lib/router/trie_node.rb
 - lib/support/config_loader.rb
-- lib/system/page_not_found_node.rb
+- lib/system/dashboard_node.rbx
+- lib/system/error_404_node.rbx
+- lib/system/events_node.rbx
+- lib/system/layout_node.rbx
+- lib/system/routes_node.rbx
 - lib/system/system.rb
-- lib/system/system_node.rb
 - lib/version.rb
 homepage: https://codeberg.org/raindeer/raindeer
 licenses: []
@@ -187,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Deer to be different
 test_files: []

data/lib/system/page_not_found_node.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class PageNotFoundNode < LowNode
-  observe Status[404]
-
-  def render(event: StatusEvent) # rubocop:disable Lint/UnusedMethodArgument
-    <<~HTML
-      <div class="page-not-found">
-        <em>404</em>
-      </div>
-    HTML
-  end
-end

data/lib/system/system_node.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'page_not_found_node'
-
-class SystemNode < LowNode
-  observe '/system'
-
-  def render(event: RouteEvent) # rubocop:disable Lint/UnusedMethodArgument
-    'SYSTEM!'
-  end
-end