raindeer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e75c9fc6090058055514d77cf30350528e2b961dd2d92088ab7407e893c5543a
-  data.tar.gz: e548dccf176c3768d42598ce1889694de5ed7919beb3e2b19bfed8112db80927
+  metadata.gz: 8783b509655bf58e51f0e7afc0aa320832d8aee1b298d50771d4121c418b28d1
+  data.tar.gz: 1eaf600341059527fc7dc013df6cc24a3bc1ba7d606a34b5544b73630e10b0ea
 SHA512:
-  metadata.gz: 7102994614563cb59203e8e711bd1210d95f5d28441f15eee224fedefbdeaab5939ce395974550161a40ec74d090a9b2cbb9e2b055da3025a450d99e978759e1
-  data.tar.gz: f4742896c7497449528bbf4e6373ac8729473c82936f700dd533efbf8afb12762daad5c636e114a3da32c98e844acb3a56d9cb357b71cf8203dbf51edb920afb
+  metadata.gz: 6328d1ed634f9e501e8abd946deccfe13e39ee68b863273bc5c6aa8b4822e449b9462bf3027a5147382802f0af2367995af807ac2144a18e66247f0c2603ceb0
+  data.tar.gz: 2268752ea3dbb8e0eb8190f007fa8263ac37e0eff6f4d1e737fbf04fc9760788e15af59e426d46e4bdd2105075a3795396f95a5d837136f6138a61c4263dc8db

data/lib/boot.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
 require 'low_dependency'
+require 'low_event'
 require 'low_loop'
+require 'low_node'
+require 'low_type'
+require 'lowload'
 
-require_relative 'router/router'
+require_relative 'matrix/matrix'
+require_relative 'support/config_loader'
 
-host = ENV.fetch('RAIN_HOST', '127.0.0.1').freeze
-port = ENV.fetch('RAIN_PORT', 4133)
-matrix_mode = ENV.fetch('RAIN_MATRIX', nil) == '1'
-mirror_mode = ENV.fetch('RAIN_MIRROR', nil) == '1'
+env = {
+  host: ENV.fetch('RAIN_HOST', nil),
+  port: ENV.fetch('RAIN_PORT', nil),
+  web_root: ENV.fetch('RAIN_WEB_ROOT', nil),
+  matrix_mode: Rain::ConfigLoader.parse_boolean(ENV.fetch('RAIN_MATRIX', nil)),
+  mirror_mode: Rain::ConfigLoader.parse_boolean(ENV.fetch('RAIN_MIRROR', nil))
+}
 
-config = Struct.new(:host, :port, :matrix_mode, :mirror_mode)
+config = Rain::ConfigLoader.load('./config/config.yaml', env)
 
 LowDependency.provide('rain.router') do
-  RainRouter.new
+  Rain::Router.new
+end
+
+LowDependency.provide('rain.matrix') do
+  Rain::Matrix.new(event_pool: Low::Providers['low.event.pool'])
 end
 
 LowDependency.provide('low.loop') do
-  # TODO: Use "def method(dependency: Dependency)" in low loop's constructor when this feature is ready.
-  LowLoop.new(config: config.new(host, port, matrix_mode, mirror_mode), router: Low::Providers['rain.router'])
+  LowLoop.new(config:, router: Low::Providers['rain.router'], renderer: Low::Providers['rain.matrix'])
 end
 
-require_relative 'system/system'
+LowLoad.dirload(File.expand_path('../system', __FILE__))

data/lib/matrix/cursor.rb

@@ -0,0 +1,32 @@
+# 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
+
+    def increment(delays:, inputs:, duration: nil)
+      next_index = @index + 1
+      duration = now - @last_update if duration.nil?
+
+      if delays[next_index] && duration >= delays[next_index]
+        @index += 1
+        @index = 0 if index >= inputs.count
+        @last_update = now
+
+        yield index
+      end
+    end
+
+    private
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+  end
+end

data/lib/matrix/matrix.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'paint'
+require 'low_event'
+require 'observers'
+
+require_relative '../support/config_loader'
+require_relative 'stream'
+
+module Rain
+  class Matrix
+    include Observers
+
+    observe Low::Events::EventPool
+
+    def initialize(event_pool:, config: Rain::ConfigLoader.load('./config/matrix.yaml'))
+      @event_pool = event_pool
+      @config = config
+
+      @screen_size = nil
+
+      @last_stream_index = -1
+      @streams = {}
+      @columns = []
+    end
+
+    def render(screen_size:, show_output: true)
+      if screen_size != @screen_size
+        @screen_size = screen_size
+        redraw_streams
+      end
+
+      render_streams(show_output:)
+    end
+
+    def update(stream_id:, event_tree:)
+      upsert_stream(stream_id:, event_tree:)
+    end
+
+    private
+
+    def redraw_streams
+      @event_pool.event_trees.each do |stream_id, event_tree|
+        stream = upsert_stream(stream_id:, event_tree:)
+        stream.redraw(cell_count: @screen_size[:row_count])
+
+        @columns[stream.index] = upsert_stream(stream_id:, event_tree:)
+      end
+    end
+
+    def render_streams(show_output:)
+      @streams.each_value { |stream| stream.render }
+
+      (0...@screen_size[:row_count]).each do |row_index|
+        cell_outputs = []
+        cell_colors = []
+
+        # Rendering streams can happen before redrawing streams and @columns haven't been populated yet (empty event pool).
+        (0...@screen_size[: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 = cell_outputs.zip(cell_colors).map do |cell, color|
+          cell ? Paint[cell, color] : Paint[' ', nil]
+        end.join(' ')
+
+        puts output if show_output
+      end
+    end
+
+    def upsert_stream(stream_id:, event_tree:)
+      @streams[stream_id] ||= Stream.new(index:, config: @config, event_tree:)
+    end
+
+    def index
+      case @config.start_col
+      when :random
+        rand(0...@screen_size[:column_count])
+      when :latest
+        @last_stream_index += 1
+        return @last_stream_index = 0 if @last_stream_index >= @screen_size[:column_count]
+        @last_stream_index
+      end
+    end
+  end
+end

data/lib/matrix/stream.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative 'cursor'
+
+module Rain
+  class Stream
+    attr_reader :index, :colors, :outputs
+
+    ARROW = ['│', '▼']
+
+    def initialize(index:, config:, event_tree:)
+      @index = index
+      @config = config
+
+      @event_tree = event_tree
+      @event_cursor = 0
+      @redraw_cursor = 0
+
+      @inputs = []
+      @delays = []
+      @colors = []
+      @outputs = []
+
+      @head_cursor = Cursor.new
+      @tail_cursor = Cursor.new
+    end
+
+    # Layout cells to fit the current cell count. Called on matrix initialization, screen size changes and on new events.
+    def redraw(cell_count:)
+      @inputs.fill(nil, 0...cell_count)[0...cell_count]
+      @delays.fill(@config.min_delay, 0...cell_count)[0...cell_count]
+      @colors.fill(@config.cell_color, 0...cell_count)[0...cell_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
+
+      @inputs
+    end
+
+    # Render a cell's input as output after a delay, using cursors. Called on every frame.
+    # ┌─┐
+    # │R│ <-- Each cell is represented as an input, delay and output.
+    # │e│
+    # │q│ <-- The head cursor outputs the cell's input after a delay and colors the leading cell white.
+    # │ │
+    # │ │ <-- The tail cursor does the same thing but the input (and therefore output) will be empty.
+    # └─┘     The tail cursor can be before or after the head cursor depending on whether events wrap around.
+    #
+    # Unit tests use "duration" to skip forwards in time, while matrix spec and the real world use old fashioned linear time.
+    def render(duration: nil)
+      @head_cursor.increment(delays:, inputs:, duration:) do |index|
+        prev_index = (index - 1).clamp(0, nil)
+        next_index = index >= @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
+
+    attr_reader :inputs, :delays
+
+    def fade(duration: nil)
+      fade_start = rand(5_000..10_000)
+
+      if (now - @head_cursor.first_update) >= fade_start || (duration && duration >= fade_start)
+        @tail_cursor.increment(delays:, inputs:, duration:) do |index|
+          if @inputs[index].nil? && @outputs[index]
+            @outputs[index] = @inputs[index]
+            @delays[index] = 0
+          end
+        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 render after the largest duration of the following values:
+    # │o│   1. The minimum delay
+    # │u│   2. The time elapsed between events divided by the number of inputs
+    # │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:)
+      if @event_cursor == 0
+        inputs = event_name(current_event:)
+        delay = @config.min_delay
+        randomize_start_row
+      else
+        inputs = [*ARROW, *event_name(current_event:)]
+        difference = current_event.created_at - past_event.created_at
+        delay = difference == 0 ? @config.min_delay : (difference / inputs.count).to_i.clamp(@config.min_delay, nil)
+      end
+
+      inputs.each do |character|
+        @inputs[@redraw_cursor] = character
+        @delays[@redraw_cursor] = @redraw_cursor == 0 ? 0 : delay # Don't add delay to the first cell, looks stuck.
+
+        @redraw_cursor += 1
+        @redraw_cursor = 0 if @redraw_cursor >= @inputs.count
+      end
+    end
+
+    def event_name(current_event:)
+      current_event.class.name.split('::').last.delete_suffix('Event').chars
+    end
+
+    def randomize_start_row
+      return unless @config.start_row == :random
+
+      random_index = rand(0..2) 
+      @redraw_cursor = random_index
+      @head_cursor.index = random_index - 1 # Head cursor always 1 index behind to make "increment" method's logic simple.
+    end
+  end
+end

data/lib/raindeer.rb

@@ -8,7 +8,7 @@ require 'observers'
 
 require_relative 'router/router'
 
-class Raindeer
+module Raindeer
   class << self
     def router(&block)
       Low::Providers['rain.router'].instance_eval(&block)

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

@@ -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 = LowType::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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'yaml'
+
+module Rain
+  class ConfigLoader
+    class << self
+      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(overrides) do |_key, old_value, new_value|
+          new_value.nil? ? old_value : new_value
+        end
+
+        OpenStruct.new(config_data)
+      end
+
+      def parse_boolean(value)
+        return true if value == '1'
+        return false if value == '0'
+
+        nil
+      end
+    end
+  end
+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 = Low::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.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raindeer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - maedi
@@ -9,6 +9,34 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  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'
+- !ruby/object:Gem::Dependency
+  name: paint
+  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'
 - !ruby/object:Gem::Dependency
   name: low_dependency
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +121,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: lowload
+  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'
 - !ruby/object:Gem::Dependency
   name: antlers
   requirement: !ruby/object:Gem::Requirement
@@ -143,15 +185,22 @@ 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
 - lib/router/router.rb
 - lib/router/trie.rb
 - lib/router/trie_node.rb
-- lib/system/page_not_found_node.rb
+- lib/support/config_loader.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: []
@@ -172,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)
-    <<~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)
-    'SYSTEM!'
-  end
-end